Moved to CppUnit for unit tests framework.

1 files changed, 252 insertions, 267 deletions

diff --git a/tests/parser/headerTest.cpp b/tests/parser/headerTest.cpp
index 83f0409e..18325f5c 100644
--- a/tests/parser/headerTest.cpp
+++ b/tests/parser/headerTest.cpp
@@ -17,356 +17,341 @@
 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 //
 
-#include "../lib/unit++/unit++.h"
+#include "tests/testUtils.hpp"
 
-#include <iostream>
-#include <ostream>
 
-#include "vmime/vmime.hpp"
-#include "vmime/platforms/posix/posixHandler.hpp"
+#define VMIME_TEST_SUITE         headerTest
+#define VMIME_TEST_SUITE_MODULE  "Parser"
 
-using namespace unitpp;
 
+VMIME_TEST_SUITE_BEGIN
 
-namespace
-{
-	class headerTest : public suite
-	{
-		static const std::string getFieldValue(const vmime::headerField& field)
-		{
-			std::ostringstream oss;
-			vmime::utility::outputStreamAdapter voss(oss);
-			field.generate(voss);
+	VMIME_TEST_LIST_BEGIN
+		VMIME_TEST(testHas1)
+		VMIME_TEST(testHas2)
 
-			return (oss.str());
-		}
+		VMIME_TEST(testAppend1)
+		VMIME_TEST(testAppend2)
 
-		// has function tests
-		void testHas1()
-		{
-			vmime::header hdr;
-			hdr.parse("From: x\r\nTo: y\r\nTo: z\r\n");
+		VMIME_TEST(testInsertFieldBefore1)
+		VMIME_TEST(testInsertFieldBefore2)
 
-			bool res = hdr.hasField("Z");
+		VMIME_TEST(testInsertFieldAfter1)
+		VMIME_TEST(testInsertFieldAfter2)
 
-			assert_eq("Value", false, res);
-		}
+		VMIME_TEST(testRemoveField1)
+		VMIME_TEST(testRemoveField2)
 
-		void testHas2()
-		{
-			vmime::header hdr;
-			hdr.parse("X: x\r\nTo: y\r\nTo: z\r\n");
+		VMIME_TEST(testRemoveAllFields)
 
-			bool res = hdr.hasField("To");
+		VMIME_TEST(testgetFieldCount)
 
-			assert_eq("Value", true, res);
-		}
+		VMIME_TEST(testIsEmpty1)
+		VMIME_TEST(testIsEmpty2)
 
-		// appendField function tests
-		void testAppend1()
-		{
-			vmime::header hdr;
-			hdr.parse("");
+		VMIME_TEST(testGetFieldAt)
 
-			vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("A", "a");
-			hdr.appendField(hf);
+		VMIME_TEST(testGetFieldList1)
+		VMIME_TEST(testGetFieldList2)
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		VMIME_TEST(testFind1)
 
-			assert_eq("Count", static_cast <unsigned int>(1), res.size());
-			assert_eq("First value", "A: a", headerTest::getFieldValue(*res[0]));
-		}
+		VMIME_TEST(testFindAllFields1)
+		VMIME_TEST(testFindAllFields2)
+		VMIME_TEST(testFindAllFields3)
+	VMIME_TEST_LIST_END
 
-		void testAppend2()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a\r\n");
 
-			vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
-			hdr.appendField(hf);
+	static const std::string getFieldValue(const vmime::headerField& field)
+	{
+		std::ostringstream oss;
+		vmime::utility::outputStreamAdapter voss(oss);
+		field.generate(voss);
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		return (oss.str());
+	}
 
-			assert_eq("Count", static_cast <unsigned int>(2), res.size());
-			assert_eq("First value", "A: a", headerTest::getFieldValue(*res[0]));
-			assert_eq("Second value", "B: b", headerTest::getFieldValue(*res[1]));
-		}
+	// has function tests
+	void testHas1()
+	{
+		vmime::header hdr;
+		hdr.parse("From: x\r\nTo: y\r\nTo: z\r\n");
 
-		// insertFieldBefore
-		void testInsertFieldBefore1()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a\r\nC: c\r\n");
+		bool res = hdr.hasField("Z");
 
-			vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
-			hdr.insertFieldBefore(hdr.getField("C"), hf);
+		VASSERT_EQ("Value", false, res);
+	}
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+	void testHas2()
+	{
+		vmime::header hdr;
+		hdr.parse("X: x\r\nTo: y\r\nTo: z\r\n");
 
-			assert_eq("Count", static_cast <unsigned int>(3), res.size());
-			assert_eq("First value", "A: a", headerTest::getFieldValue(*res[0]));
-			assert_eq("Second value", "B: b", headerTest::getFieldValue(*res[1]));
-			assert_eq("Third value", "C: c", headerTest::getFieldValue(*res[2]));
-		}
+		bool res = hdr.hasField("To");
 
-		void testInsertFieldBefore2()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a\r\nC: c\r\n");
+		VASSERT_EQ("Value", true, res);
+	}
 
-			vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
-			hdr.insertFieldBefore(1, hf);
+	// appendField function tests
+	void testAppend1()
+	{
+		vmime::header hdr;
+		hdr.parse("");
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("A", "a");
+		hdr.appendField(hf);
 
-			assert_eq("Count", static_cast <unsigned int>(3), res.size());
-			assert_eq("First value", "A: a", headerTest::getFieldValue(*res[0]));
-			assert_eq("Second value", "B: b", headerTest::getFieldValue(*res[1]));
-			assert_eq("Third value", "C: c", headerTest::getFieldValue(*res[2]));
-		}
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
 
-		// insertFieldAfter
-		void testInsertFieldAfter1()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a\r\nC: c\r\n");
+		VASSERT_EQ("Count", static_cast <unsigned int>(1), res.size());
+		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
+	}
 
-			vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
-			hdr.insertFieldAfter(hdr.getField("A"), hf);
+	void testAppend2()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a\r\n");
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
+		hdr.appendField(hf);
 
-			assert_eq("Count", static_cast <unsigned int>(3), res.size());
-			assert_eq("First value", "A: a", headerTest::getFieldValue(*res[0]));
-			assert_eq("Second value", "B: b", headerTest::getFieldValue(*res[1]));
-			assert_eq("Third value", "C: c", headerTest::getFieldValue(*res[2]));
-		}
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
 
-		void testInsertFieldAfter2()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a\r\nC: c\r\n");
+		VASSERT_EQ("Count", static_cast <unsigned int>(2), res.size());
+		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
+		VASSERT_EQ("Second value", "B: b", headerTest::getFieldValue(*res[1]));
+	}
 
-			vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
-			hdr.insertFieldAfter(0, hf);
+	// insertFieldBefore
+	void testInsertFieldBefore1()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a\r\nC: c\r\n");
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
+		hdr.insertFieldBefore(hdr.getField("C"), hf);
 
-			assert_eq("Count", static_cast <unsigned int>(3), res.size());
-			assert_eq("First value", "A: a", headerTest::getFieldValue(*res[0]));
-			assert_eq("Second value", "B: b", headerTest::getFieldValue(*res[1]));
-			assert_eq("Third value", "C: c", headerTest::getFieldValue(*res[2]));
-		}
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
 
-		// removeField
-		void testRemoveField1()
-		{
-			vmime::header hdr1, hdr2;
-			hdr1.parse("A: a\r\nB: b\r\nC: c\r\n");
-			hdr2.parse("A: a\r\nB: b\r\nC: c\r\n");
-
-			hdr1.removeField(hdr1.getField("B"));
-			hdr2.removeField(1);
+		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
+		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
+		VASSERT_EQ("Second value", "B: b", headerTest::getFieldValue(*res[1]));
+		VASSERT_EQ("Third value", "C: c", headerTest::getFieldValue(*res[2]));
+	}
 
-			std::vector <vmime::ref <vmime::headerField> > res1 = hdr1.getFieldList();
-
-			assert_eq("Count", static_cast <unsigned int>(2), res1.size());
-			assert_eq("First value", "A: a", headerTest::getFieldValue(*res1[0]));
-			assert_eq("Second value", "C: c", headerTest::getFieldValue(*res1[1]));
-
-			std::vector <vmime::ref <vmime::headerField> > res2 = hdr2.getFieldList();
+	void testInsertFieldBefore2()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a\r\nC: c\r\n");
 
-			assert_eq("Count", static_cast <unsigned int>(2), res2.size());
-			assert_eq("First value", "A: a", headerTest::getFieldValue(*res2[0]));
-			assert_eq("Second value", "C: c", headerTest::getFieldValue(*res2[1]));
-		}
-
-		void testRemoveField2()
-		{
-			vmime::header hdr1, hdr2;
-			hdr1.parse("A: a\r\n");
-			hdr2.parse("A: a\r\n");
+		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
+		hdr.insertFieldBefore(1, hf);
 
-			hdr1.removeField(hdr1.getField("A"));
-			hdr2.removeField(0);
-
-			std::vector <vmime::ref <vmime::headerField> > res1 = hdr1.getFieldList();
-			assert_eq("Count", static_cast <unsigned int>(0), res1.size());
-
-			std::vector <vmime::ref <vmime::headerField> > res2 = hdr2.getFieldList();
-			assert_eq("Count", static_cast <unsigned int>(0), res2.size());
-		}
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
 
-		// removeAllFields
-		void testRemoveAllFields()
-		{
-			vmime::header hdr1, hdr2;
-			hdr1.parse("A: a\r\n");
-			hdr2.parse("A: a\r\nB: b\r\n");
-
-			hdr1.removeAllFields();
-			hdr2.removeAllFields();
+		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
+		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
+		VASSERT_EQ("Second value", "B: b", headerTest::getFieldValue(*res[1]));
+		VASSERT_EQ("Third value", "C: c", headerTest::getFieldValue(*res[2]));
+	}
 
-			std::vector <vmime::ref <vmime::headerField> > res1 = hdr1.getFieldList();
-			assert_eq("Count", static_cast <unsigned int>(0), res1.size());
+	// insertFieldAfter
+	void testInsertFieldAfter1()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a\r\nC: c\r\n");
 
-			std::vector <vmime::ref <vmime::headerField> > res2 = hdr2.getFieldList();
-			assert_eq("Count", static_cast <unsigned int>(0), res2.size());
-		}
+		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
+		hdr.insertFieldAfter(hdr.getField("A"), hf);
 
-		// getFieldCount
-		void testgetFieldCount()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a\r\nB: b\r\nC: c\r\nD: d\r\n");
-
-			assert_eq("Value", 4, hdr.getFieldCount());
-		}
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
 
-		// isEmpty
-		void testIsEmpty1()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a\r\nB: b\r\nC: c\r\n");
+		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
+		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
+		VASSERT_EQ("Second value", "B: b", headerTest::getFieldValue(*res[1]));
+		VASSERT_EQ("Third value", "C: c", headerTest::getFieldValue(*res[2]));
+	}
 
-			assert_eq("Value", false, hdr.isEmpty());
-		}
+	void testInsertFieldAfter2()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a\r\nC: c\r\n");
 
-		void testIsEmpty2()
-		{
-			vmime::header hdr;
-			hdr.parse("\r\n");
+		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
+		hdr.insertFieldAfter(0, hf);
 
-			assert_eq("Value", true, hdr.isEmpty());
-		}
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
 
-		// getFieldAt
-		void getFieldAt()
-		{
-			vmime::header hdr;
-			hdr.parse("B: b\r\nA: a\r\nC: c\r\n");
+		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
+		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
+		VASSERT_EQ("Second value", "B: b", headerTest::getFieldValue(*res[1]));
+		VASSERT_EQ("Third value", "C: c", headerTest::getFieldValue(*res[2]));
+	}
 
-			vmime::ref <vmime::headerField> res = hdr.getFieldAt(2);
+	// removeField
+	void testRemoveField1()
+	{
+		vmime::header hdr1, hdr2;
+		hdr1.parse("A: a\r\nB: b\r\nC: c\r\n");
+		hdr2.parse("A: a\r\nB: b\r\nC: c\r\n");
 
-			assert_eq("Value", "C: c", getFieldValue(*res));
-		}
+		hdr1.removeField(hdr1.getField("B"));
+		hdr2.removeField(1);
 
-		// getFieldList
-		void testGetFieldList1()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a\r\nB: b1\r\nC: c\r\nB: b2\r\n");
+		std::vector <vmime::ref <vmime::headerField> > res1 = hdr1.getFieldList();
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.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]));
 
-			assert_eq("Count", static_cast <unsigned int>(4), res.size());
-			assert_eq("First value", "A: a", headerTest::getFieldValue(*res[0]));
-			assert_eq("Second value", "B: b1", headerTest::getFieldValue(*res[1]));
-			assert_eq("Third value", "C: c", headerTest::getFieldValue(*res[2]));
-			assert_eq("Thourth value", "B: b2", headerTest::getFieldValue(*res[3]));
-		}
+		std::vector <vmime::ref <vmime::headerField> > res2 = hdr2.getFieldList();
 
-		void testGetFieldList2()
-		{
-			vmime::header hdr;
-			hdr.parse("\r\n");
+		VASSERT_EQ("Count", static_cast <unsigned int>(2), res2.size());
+		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res2[0]));
+		VASSERT_EQ("Second value", "C: c", headerTest::getFieldValue(*res2[1]));
+	}
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+	void testRemoveField2()
+	{
+		vmime::header hdr1, hdr2;
+		hdr1.parse("A: a\r\n");
+		hdr2.parse("A: a\r\n");
 
-			assert_eq("Count", static_cast <unsigned int>(0), res.size());
-		}
+		hdr1.removeField(hdr1.getField("A"));
+		hdr2.removeField(0);
 
-		// find function tests
-		void testFind1()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a\r\nB: b\r\nC: c\r\nB: d\r\n");
+		std::vector <vmime::ref <vmime::headerField> > res1 = hdr1.getFieldList();
+		VASSERT_EQ("Count", static_cast <unsigned int>(0), res1.size());
 
-			vmime::ref <vmime::headerField> res = hdr.findField("B");
+		std::vector <vmime::ref <vmime::headerField> > res2 = hdr2.getFieldList();
+		VASSERT_EQ("Count", static_cast <unsigned int>(0), res2.size());
+	}
 
-			assert_eq("Value", "B: b", getFieldValue(*res));
-		}
+	// removeAllFields
+	void testRemoveAllFields()
+	{
+		vmime::header hdr1, hdr2;
+		hdr1.parse("A: a\r\n");
+		hdr2.parse("A: a\r\nB: b\r\n");
 
-		// getAllByName function tests
-		void testFindAllFields1()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a1\nC: c1\n");
+		hdr1.removeAllFields();
+		hdr2.removeAllFields();
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.findAllFields("B");
+		std::vector <vmime::ref <vmime::headerField> > res1 = hdr1.getFieldList();
+		VASSERT_EQ("Count", static_cast <unsigned int>(0), res1.size());
 
-			assert_eq("Count", static_cast <unsigned int>(0), res.size());
-		}
+		std::vector <vmime::ref <vmime::headerField> > res2 = hdr2.getFieldList();
+		VASSERT_EQ("Count", static_cast <unsigned int>(0), res2.size());
+	}
 
-		void testFindAllFields2()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a1\nB: b1\nB: b2\nC: c1\n");
+	// getFieldCount
+	void testgetFieldCount()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a\r\nB: b\r\nC: c\r\nD: d\r\n");
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.findAllFields("B");
+		VASSERT_EQ("Value", 4, hdr.getFieldCount());
+	}
 
-			assert_eq("Count", static_cast <unsigned int>(2), res.size());
-			assert_eq("First value", "B: b1", headerTest::getFieldValue(*res[0]));
-			assert_eq("Second value", "B: b2", headerTest::getFieldValue(*res[1]));
-		}
+	// isEmpty
+	void testIsEmpty1()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a\r\nB: b\r\nC: c\r\n");
 
-		void testFindAllFields3()
-		{
-			vmime::header hdr;
-			hdr.parse("A: a1\nB: b1\nB: b2\nC: c1\nC: c3\nC: c2\n");
+		VASSERT_EQ("Value", false, hdr.isEmpty());
+	}
 
-			std::vector <vmime::ref <vmime::headerField> > res = hdr.findAllFields("C");
+	void testIsEmpty2()
+	{
+		vmime::header hdr;
+		hdr.parse("\r\n");
+
+		VASSERT_EQ("Value", true, hdr.isEmpty());
+	}
+
+	// getFieldAt
+	void testGetFieldAt()
+	{
+		vmime::header hdr;
+		hdr.parse("B: b\r\nA: a\r\nC: c\r\n");
+
+		vmime::ref <vmime::headerField> res = hdr.getFieldAt(2);
+
+		VASSERT_EQ("Value", "C: c", getFieldValue(*res));
+	}
+
+	// getFieldList
+	void testGetFieldList1()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a\r\nB: b1\r\nC: c\r\nB: b2\r\n");
 
-			assert_eq("Count", static_cast <unsigned int>(3), res.size());
-			assert_eq("First value", "C: c1", headerTest::getFieldValue(*res[0]));
-			assert_eq("Second value", "C: c3", headerTest::getFieldValue(*res[1]));
-			assert_eq("Second value", "C: c2", headerTest::getFieldValue(*res[2]));
-		}
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
 
-	public:
+		VASSERT_EQ("Count", static_cast <unsigned int>(4), res.size());
+		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
+		VASSERT_EQ("Second value", "B: b1", headerTest::getFieldValue(*res[1]));
+		VASSERT_EQ("Third value", "C: c", headerTest::getFieldValue(*res[2]));
+		VASSERT_EQ("Thourth value", "B: b2", headerTest::getFieldValue(*res[3]));
+	}
 
-		headerTest() : suite("vmime::header")
-		{
-			// VMime initialization
-			vmime::platformDependant::setHandler<vmime::platforms::posix::posixHandler>();
+	void testGetFieldList2()
+	{
+		vmime::header hdr;
+		hdr.parse("\r\n");
 
-			add("Has", testcase(this, "Has1", &headerTest::testHas1));
-			add("Has", testcase(this, "Has2", &headerTest::testHas2));
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
 
-			add("Append", testcase(this, "Append1", &headerTest::testAppend1));
-			add("Append", testcase(this, "Append2", &headerTest::testAppend2));
+		VASSERT_EQ("Count", static_cast <unsigned int>(0), res.size());
+	}
 
-			add("InsertFieldBefore", testcase(this, "InsertFieldBefore1", &headerTest::testInsertFieldBefore1));
-			add("InsertFieldBefore", testcase(this, "InsertFieldBefore2", &headerTest::testInsertFieldBefore2));
+	// find function tests
+	void testFind1()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a\r\nB: b\r\nC: c\r\nB: d\r\n");
 
-			add("InsertFieldAfter", testcase(this, "InsertFieldAfter1", &headerTest::testInsertFieldAfter1));
-			add("InsertFieldAfter", testcase(this, "InsertFieldAfter2", &headerTest::testInsertFieldAfter2));
+		vmime::ref <vmime::headerField> res = hdr.findField("B");
 
-			add("RemoveField", testcase(this, "RemoveField1", &headerTest::testRemoveField1));
-			add("RemoveField", testcase(this, "RemoveField2", &headerTest::testRemoveField2));
+		VASSERT_EQ("Value", "B: b", getFieldValue(*res));
+	}
 
-			add("RemoveAllFields", testcase(this, "RemoveAllFields", &headerTest::testRemoveAllFields));
+	// getAllByName function tests
+	void testFindAllFields1()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a1\nC: c1\n");
 
-			add("GetFieldCount", testcase(this, "GetFieldCount", &headerTest::testgetFieldCount));
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.findAllFields("B");
 
-			add("IsEmpty", testcase(this, "IsEmpty1", &headerTest::testIsEmpty1));
-			add("IsEmpty", testcase(this, "IsEmpty2", &headerTest::testIsEmpty2));
+		VASSERT_EQ("Count", static_cast <unsigned int>(0), res.size());
+	}
 
-			add("GetFieldAt", testcase(this, "GetFieldAt", &headerTest::getFieldAt));
+	void testFindAllFields2()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a1\nB: b1\nB: b2\nC: c1\n");
+
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.findAllFields("B");
 
-			add("GetFieldList", testcase(this, "GetFieldList1", &headerTest::testGetFieldList1));
-			add("GetFieldList", testcase(this, "GetFieldList2", &headerTest::testGetFieldList2));
+		VASSERT_EQ("Count", static_cast <unsigned int>(2), res.size());
+		VASSERT_EQ("First value", "B: b1", headerTest::getFieldValue(*res[0]));
+		VASSERT_EQ("Second value", "B: b2", headerTest::getFieldValue(*res[1]));
+	}
 
-			add("Find", testcase(this, "Find1", &headerTest::testFind1));
+	void testFindAllFields3()
+	{
+		vmime::header hdr;
+		hdr.parse("A: a1\nB: b1\nB: b2\nC: c1\nC: c3\nC: c2\n");
 
-			add("FindAllFields", testcase(this, "FindAllFields1", &headerTest::testFindAllFields1));
-			add("FindAllFields", testcase(this, "FindAllFields2", &headerTest::testFindAllFields2));
-			add("FindAllFields", testcase(this, "FindAllFields3", &headerTest::testFindAllFields3));
+		std::vector <vmime::ref <vmime::headerField> > res = hdr.findAllFields("C");
 
-			suite::main().add("vmime::header", this);
-		}
+		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
+		VASSERT_EQ("First value", "C: c1", headerTest::getFieldValue(*res[0]));
+		VASSERT_EQ("Second value", "C: c3", headerTest::getFieldValue(*res[1]));
+		VASSERT_EQ("Second value", "C: c2", headerTest::getFieldValue(*res[2]));
+	}
 
-	};
+VMIME_TEST_SUITE_END
 
-	headerTest* theTest = new headerTest();
-}