+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testAddAttachment1)

+ VMIME_TEST(testAddAttachment2)

+ VMIME_TEST(testAddAttachment3)

+ VMIME_TEST(testIsBodyPartAnAttachment1)

+ VMIME_TEST(testIsBodyPartAnAttachment2)

+ VMIME_TEST(testIsBodyPartAnAttachment3)

+ VMIME_TEST(testGetBodyPartAttachment)

+ VMIME_TEST(testAddAttachmentMessage1)

+ VMIME_TEST(testGetBodyPartAttachmentMessage)

+ VMIME_TEST_LIST_END

+

+

+ static const vmime::string getStructure(const vmime::shared_ptr <vmime::bodyPart>& part) {

+

+ vmime::shared_ptr <vmime::body> bdy = part->getBody();

+

+ vmime::string res = part->getBody()->getContentType().generate();

+

+ if (bdy->getPartCount() == 0) {

+ return res;

+ }

+

+ res += "[";

+

+ for (size_t i = 0 ; i < bdy->getPartCount() ; ++i) {

+

+ vmime::shared_ptr <vmime::bodyPart> subPart = bdy->getPartAt(i);

+

+ if (i != 0) {

+ res += ",";

+ }

+

+ res += getStructure(subPart);

+ }

+

+ return res + "]";

+ }

+

+ static const vmime::string extractBodyContents(

+ const vmime::shared_ptr <const vmime::bodyPart>& part

+ ) {

+

+ vmime::shared_ptr <const vmime::contentHandler> cth = part->getBody()->getContents();

+

+ vmime::string data;

+ vmime::utility::outputStreamStringAdapter os(data);

+

+ cth->extract(os);

+

+ return data;

+ }

+

+ void testAddAttachment1() {

+

+ vmime::string data =

+"Content-Type: text/plain\r\n"

+"\r\n"

+"The text\r\n"

+"";

+

+ vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ msg->parse(data);

+

+ 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);

+

+ VASSERT_EQ("1", "multipart/mixed[text/plain,image/jpeg]", getStructure(msg));

+ VASSERT_EQ("2", "The text\r\n", extractBodyContents(msg->getBody()->getPartAt(0)));

+ }

+

+ void testAddAttachment2() {

+

+ vmime::string data =

+"Content-Type: multipart/mixed; boundary=\"foo\"\r\n"

+"\r\n"

+"--foo\r\n"

+"Content-Type: text/plain\r\n"

+"\r\n"

+"The text\r\n"

+"--foo\r\n"

+"Content-Type: application/octet-stream\r\n"

+"\r\n"

+"Blah\r\n"

+"--foo--\r\n"

+"";

+

+ vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ msg->parse(data);

+

+ 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);

+

+ VASSERT_EQ("1", "multipart/mixed[text/plain,application/octet-stream,image/jpeg]", getStructure(msg));

+ VASSERT_EQ("2", "The text", extractBodyContents(msg->getBody()->getPartAt(0)));

+ VASSERT_EQ("3", "Blah", extractBodyContents(msg->getBody()->getPartAt(1)));

+ VASSERT_EQ("4", "test", extractBodyContents(msg->getBody()->getPartAt(2)));

+ }

+

+ // Initial part is encoded

+ void testAddAttachment3() {

+

+ vmime::string data =

+"Content-Type: text/plain\r\n"

+"Content-Transfer-Encoding: base64\r\n"

+"\r\n"

+"TWVzc2FnZSBib2R5";

+

+ vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ msg->parse(data);

+

+ 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);

+

+ VASSERT_EQ("1", "multipart/mixed[text/plain,image/jpeg]", getStructure(msg));

+ VASSERT_EQ("2", "Message body", extractBodyContents(msg->getBody()->getPartAt(0)));

+ }

+

+ // Content-Disposition: attachment

+ // No other field

+ void testIsBodyPartAnAttachment1() {

+

+ vmime::string data = "Content-Disposition: attachment\r\n\r\nFoo\r\n";

+

+ vmime::shared_ptr <vmime::bodyPart> p = vmime::make_shared <vmime::bodyPart>();

+ p->parse(data);

+

+ VASSERT_EQ("1", true, vmime::attachmentHelper::isBodyPartAnAttachment(p));

+ }

+

+ // No Content-Disposition field

+ // Content-Type: multipart/* or text/*

+ void testIsBodyPartAnAttachment2() {

+

+ vmime::string data = "Content-Type: multipart/*\r\n\r\nFoo\r\n";

+

+ vmime::shared_ptr <vmime::bodyPart> p = vmime::make_shared <vmime::bodyPart>();

+ p->parse(data);

+

+ VASSERT_EQ("1", false, vmime::attachmentHelper::isBodyPartAnAttachment(p));

+

+ data = "Content-Type: text/*\r\n\r\nFoo\r\n";

+

+ p->parse(data);

+

+ VASSERT_EQ("2", false, vmime::attachmentHelper::isBodyPartAnAttachment(p));

+ }

+

+ // No Content-Disposition field

+ void testIsBodyPartAnAttachment3() {

+

+ vmime::string data = "Content-Type: application/octet-stream\r\n\r\nFoo\r\n";

+

+ vmime::shared_ptr <vmime::bodyPart> p = vmime::make_shared <vmime::bodyPart>();

+ p->parse(data);

+

+ VASSERT_EQ("1", true, vmime::attachmentHelper::isBodyPartAnAttachment(p));

+ }

+

+ // Content-Disposition: attachment

+ // Content-Id field present

+ void testIsBodyPartAnAttachment4() {

+

+ vmime::string data = "Content-Disposition: attachment\r\n"

+ "Content-Type: application/octet-stream\r\n"

+ "Content-Id: bar\r\n"

+ "\r\nFoo\r\n";

+

+ vmime::shared_ptr <vmime::bodyPart> p = vmime::make_shared <vmime::bodyPart>();

+ p->parse(data);

+

+ VASSERT_EQ("1", false, vmime::attachmentHelper::isBodyPartAnAttachment(p));

+ }

+

+ void testGetBodyPartAttachment() {

+

+ vmime::string data =

+ "Content-Type: image/jpeg\r\n"

+ "Content-Description: foobar\r\n"

+ "Content-Transfer-Encoding: x-baz\r\n"

+ "Content-Disposition: attachment; filename=\"foobar.baz\"\r\n"

+ "\r\n"

+ "Foo bar baz";

+

+ vmime::shared_ptr <vmime::bodyPart> part = vmime::make_shared <vmime::bodyPart>();

+ part->parse(data);

+

+ vmime::shared_ptr <const vmime::attachment> att =

+ vmime::attachmentHelper::getBodyPartAttachment(part);

+

+ VASSERT_EQ("1", "image/jpeg", att->getType().generate());

+ VASSERT_EQ("2", "foobar", att->getDescription().generate());

+ VASSERT_EQ("3", "x-baz", att->getEncoding().generate());

+ VASSERT_EQ("4", "foobar.baz", att->getName().generate());

+

+ vmime::string attData;

+ vmime::utility::outputStreamStringAdapter out(attData);

+ att->getData()->extractRaw(out); // 'x-baz' encoding not supported

+

+ VASSERT_EQ("5", "Foo bar baz", attData);

+

+ //VASSERT_EQ("6", part, att->getPart());

+ 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());

+ }

+

+ void testAddAttachmentMessage1() {

+

+ const vmime::string data =

+"Subject: Test message\r\n"

+"Content-Type: text/plain\r\n"

+"\r\n"

+"Message body";

+

+ vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ msg->parse(data);

+

+ const vmime::string attData =

+"Subject: Attached message\r\n"

+"Content-Type: text/plain\r\n"

+"Content-Transfer-Encoding: base64\r\n"

+"\r\n"

+"QXR0YWNoZWQgbWVzc2FnZSBib2R5";

+

+ vmime::shared_ptr <vmime::message> amsg = vmime::make_shared <vmime::message>();

+ amsg->parse(attData);

+

+ vmime::attachmentHelper::addAttachment(msg, amsg);

+

+ VASSERT_EQ("1", "multipart/mixed[text/plain,message/rfc822]", getStructure(msg));

+ VASSERT_EQ("2", "Message body", extractBodyContents(msg->getBody()->getPartAt(0)));

+

+ // Ensure message has been encoded properly

+ 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::shared_ptr <vmime::message> amsgOut = vmime::make_shared <vmime::message>();

+ amsgOut->parse(attDataOut);

+

+ vmime::shared_ptr <vmime::header> hdr = amsgOut->getHeader();

+

+ VASSERT_EQ("3", "Attached message", hdr->Subject()->getValue <vmime::text>()->generate());

+ VASSERT_EQ("4", "Attached message body", extractBodyContents(amsgOut));

+ }

+

+ void testGetBodyPartAttachmentMessage() {

+

+ const vmime::string data =

+"Subject: Test message\r\n"

+"Content-Type: multipart/mixed; boundary=\"foo\"\r\n"

+"\r\n"

+"--foo\r\n"

+"Content-Type: message/rfc822\r\n"

+"\r\n"

+"Subject: Attached message\r\n"

+"\r\n"

+"Attached message body\r\n"

+"--foo\r\n"

+"Content-Type: text/plain\r\n"

+"\r\n"

+"FooBar\r\n"

+"--foo--\r\n";

+

+ vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ msg->parse(data);

+

+ VASSERT_EQ("0", 2, msg->getBody()->getPartCount());

+

+ vmime::shared_ptr <const vmime::attachment> att =

+ vmime::attachmentHelper::getBodyPartAttachment(msg->getBody()->getPartAt(0));

+

+ VASSERT("1", att != NULL);

+

+ vmime::shared_ptr <const vmime::messageAttachment> msgAtt =

+ vmime::dynamicCast <const vmime::messageAttachment>(att);

+

+ VASSERT("2", msgAtt != NULL);

+

+ vmime::shared_ptr <vmime::message> amsg = msgAtt->getMessage();

+ vmime::shared_ptr <vmime::header> hdr = amsg->getHeader();

+

+ VASSERT_EQ("3", "Attached message", hdr->Subject()->getValue <vmime::text>()->generate());

+ VASSERT_EQ("4", "Attached message body", extractBodyContents(amsg));

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(bodyPartTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParse)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST(testParseGuessBoundary)

+ VMIME_TEST(testParseGuessBoundaryWithTransportPadding)

+ VMIME_TEST(testParseMissingLastBoundary)

+ VMIME_TEST(testPrologEpilog)

+ VMIME_TEST(testPrologEncoding)

+ VMIME_TEST(testSuccessiveBoundaries)

+ VMIME_TEST(testTransportPaddingInBoundary)

+ VMIME_TEST(testGenerate7bit)

+ VMIME_TEST(testTextUsageForQPEncoding)

+ VMIME_TEST(testParseVeryBigMessage)

+ VMIME_TEST(testParseBoundaryPrefix)

+ VMIME_TEST_LIST_END

+

+

+ static const vmime::string extractComponentString(

+ const vmime::string& buffer,

+ const vmime::component& c

+ ) {

+

+ return vmime::string(

+ buffer.begin() + c.getParsedOffset(),

+ buffer.begin() + c.getParsedOffset() + c.getParsedLength()

+ );

+ }

+

+ static const vmime::string extractContents(

+ const vmime::shared_ptr <const vmime::contentHandler>& cts

+ ) {

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter os(oss);

+

+ cts->extract(os);

+

+ return oss.str();

+ }

+

+

+ void testParse() {

+

+ vmime::string str1 = "HEADER\r\n\r\nBODY";

+ vmime::bodyPart p1;

+ p1.parse(str1);

+

+ VASSERT_EQ("1", "HEADER\r\n\r\n", extractComponentString(str1, *p1.getHeader()));

+ VASSERT_EQ("2", "BODY", extractComponentString(str1, *p1.getBody()));

+

+ vmime::string str2 = "HEADER\n\nBODY";

+ vmime::bodyPart p2;

+ p2.parse(str2);

+

+ VASSERT_EQ("3", "HEADER\n\n", extractComponentString(str2, *p2.getHeader()));

+ VASSERT_EQ("4", "BODY", extractComponentString(str2, *p2.getBody()));

+

+ vmime::string str3 = "HEADER\r\n\nBODY";

+ vmime::bodyPart p3;

+ p3.parse(str3);

+

+ VASSERT_EQ("5", "HEADER\r\n\n", extractComponentString(str3, *p3.getHeader()));

+ VASSERT_EQ("6", "BODY", extractComponentString(str3, *p3.getBody()));

+ }

+

+ void testParseMissingLastBoundary() {

+

+ vmime::string str =

+ "Content-Type: multipart/mixed; boundary=\"MY-BOUNDARY\""

+ "\r\n\r\n"

+ "--MY-BOUNDARY\r\nHEADER1\r\n\r\nBODY1\r\n"

+ "--MY-BOUNDARY\r\nHEADER2\r\n\r\nBODY2";

+

+ vmime::bodyPart p;

+ p.parse(str);

+

+ VASSERT_EQ("count", 2, p.getBody()->getPartCount());

+

+ VASSERT_EQ("part1-body", "BODY1", extractContents(p.getBody()->getPartAt(0)->getBody()->getContents()));

+ VASSERT_EQ("part2-body", "BODY2", extractContents(p.getBody()->getPartAt(1)->getBody()->getContents()));

+ }

+

+ void testGenerate() {

+

+ vmime::bodyPart p1;

+ p1.getHeader()->getField("Foo")->setValue(vmime::string("bar"));

+ p1.getBody()->setContents(vmime::make_shared <vmime::stringContentHandler>("Baz"));

+

+ VASSERT_EQ("1", "Foo: bar\r\n\r\nBaz", p1.generate());

+ }

+

+ void testPrologEpilog() {

+

+ const char testMail[] =

+ "To: test@vmime.org\r\n"

+ "From: test@vmime.org\r\n"

+ "Subject: Prolog and epilog test\r\n"

+ "Content-Type: multipart/mixed; \r\n"

+ " boundary=\"=_boundary\"\r\n"

+ "\r\n"

+ "Prolog text\r\n"

+ "--=_boundary\r\n"

+ "Content-Type: text/plain\r\n"

+ "\r\n"

+ "Part1\r\n"

+ "--=_boundary--\r\n"

+ "Epilog text";

+

+ vmime::bodyPart part;

+ part.parse(testMail);

+

+ VASSERT_EQ("prolog", "Prolog text", part.getBody()->getPrologText());

+ VASSERT_EQ("epilog", "Epilog text", part.getBody()->getEpilogText());

+ }

+

+ // Test for bug fix: prolog should not be encoded

+ // http://sourceforge.net/tracker/?func=detail&atid=525568&aid=3174903&group_id=69724

+ void testPrologEncoding() {

+

+ const char testmail[] =

+ "To: test@vmime.org\r\n"

+ "From: test@vmime.org\r\n"

+ "Subject: Prolog encoding test\r\n"

+ "Content-Type: multipart/mixed; \r\n"

+ " boundary=\"=_+ZWjySayKqSf2CyrfnNpaAcO6-G1HpoXdHZ4YyswAWqEY39Q\"\r\n"

+ "\r\n"

+ "This is a multi-part message in MIME format. Your mail reader does not\r\n"

+ "understand MIME message format.\r\n"

+ "--=_+ZWjySayKqSf2CyrfnNpaAcO6-G1HpoXdHZ4YyswAWqEY39Q\r\n"

+ "Content-Type: text/html; charset=windows-1251\r\n"

+ "Content-Transfer-Encoding: quoted-printable\r\n"

+ "\r\n"

+ "=DD=F2=EE =F2=E5=EA=F1=F2=EE=E2=E0=FF =F7=E0=F1=F2=FC =F1=EB=EE=E6=ED=EE=E3=\r\n"

+ "=EE =F1=EE=EE=E1=F9=E5=ED=E8=FF\r\n"

+ "--=_+ZWjySayKqSf2CyrfnNpaAcO6-G1HpoXdHZ4YyswAWqEY39Q\r\n"

+ "Content-Type: application/octet-stream; charset=windows-1251\r\n"

+ "Content-Disposition: attachment; filename=FNS.zip\r\n"

+ "Content-Transfer-Encoding: base64\r\n"

+ "\r\n"

+ "UEsDBB...snap...EEAAAAAA==\r\n"

+ "--=_+ZWjySayKqSf2CyrfnNpaAcO6-G1HpoXdHZ4YyswAWqEY39Q--\r\n"

+ "Epilog text";

+

+ vmime::shared_ptr<vmime::message> msg = vmime::make_shared<vmime::message>();

+

+ std::string istr(testmail);

+

+ std::string ostr;

+ vmime::utility::outputStreamStringAdapter out(ostr);

+

+ for (int i = 0 ; i < 10 ; ++i) {

+

+ ostr.clear();

+

+ msg->parse(istr);

+ msg->generate(out);

+

+ istr = ostr;

+ }

+

+ VASSERT_EQ("prolog", "This is a multi-part message in MIME format. Your mail reader"

+ " does not understand MIME message format.", msg->getBody()->getPrologText());

+ VASSERT_EQ("epilog", "Epilog text", msg->getBody()->getEpilogText());

+ }

+

+ void testSuccessiveBoundaries() {

+

+ vmime::string str =

+ "Content-Type: multipart/mixed; boundary=\"MY-BOUNDARY\""

+ "\r\n\r\n"

+ "--MY-BOUNDARY\r\nHEADER1\r\n\r\nBODY1\r\n"

+ "--MY-BOUNDARY\r\n"

+ "--MY-BOUNDARY--\r\n";

+

+ vmime::bodyPart p;

+ p.parse(str);

+

+ VASSERT_EQ("count", 2, p.getBody()->getPartCount());

+

+ VASSERT_EQ("part1-body", "BODY1", extractContents(p.getBody()->getPartAt(0)->getBody()->getContents()));

+ VASSERT_EQ("part2-body", "", extractContents(p.getBody()->getPartAt(1)->getBody()->getContents()));

+ }

+

+ void testTransportPaddingInBoundary() {

+

+ vmime::string str =

+ "Content-Type: multipart/mixed; boundary=\"MY-BOUNDARY\""

+ "\r\n\r\n"

+ "--MY-BOUNDARY \t \r\nHEADER1\r\n\r\nBODY1\r\n"

+ "--MY-BOUNDARY\r\n"

+ "--MY-BOUNDARY-- \r\n";

+

+ vmime::bodyPart p;

+ p.parse(str);

+

+ VASSERT_EQ("count", 2, p.getBody()->getPartCount());

+

+ VASSERT_EQ("part1-body", "BODY1", extractContents(p.getBody()->getPartAt(0)->getBody()->getContents()));

+ VASSERT_EQ("part2-body", "", extractContents(p.getBody()->getPartAt(1)->getBody()->getContents()));

+ }

+

+ /** Ensure '7bit' encoding is used when body is 7-bit only. */

+ void testGenerate7bit() {

+

+ vmime::shared_ptr <vmime::plainTextPart> p1 = vmime::make_shared <vmime::plainTextPart>();

+ p1->setText(vmime::make_shared <vmime::stringContentHandler>("Part1 is US-ASCII only."));

+

+ vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ p1->generateIn(msg, msg);

+

+ vmime::shared_ptr <vmime::header> header1 = msg->getBody()->getPartAt(0)->getHeader();

+ VASSERT_EQ("1", "7bit", header1->ContentTransferEncoding()->getValue()->generate());

+ }

+

+ void testTextUsageForQPEncoding() {

+

+ 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::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ part->generateIn(msg, msg);

+

+ 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);

+ body->generate(os, 80);

+

+ VASSERT_EQ("1", "quoted-printable", header->ContentTransferEncoding()->getValue()->generate());

+

+ // This should *NOT* be:

+ // Part1-line1=0D=0APart1-line2=0D=0A=89

+ VASSERT_EQ("2", "Part1-line1\r\nPart1-line2\r\n=89", oss.str());

+ }

+

+ void testParseGuessBoundary() {

+

+ // Boundary is not specified in "Content-Type" field

+ // Parser will try to guess it from message contents.

+

+ vmime::string str =

+ "Content-Type: multipart/mixed"

+ "\r\n\r\n"

+ "--UNKNOWN-BOUNDARY\r\nHEADER1\r\n\r\nBODY1\r\n"

+ "--UNKNOWN-BOUNDARY\r\nHEADER2\r\n\r\nBODY2\r\n"

+ "--UNKNOWN-BOUNDARY--";

+

+ vmime::bodyPart p;

+ p.parse(str);

+

+ VASSERT_EQ("count", 2, p.getBody()->getPartCount());

+

+ VASSERT_EQ("part1-body", "BODY1", extractContents(p.getBody()->getPartAt(0)->getBody()->getContents()));

+ VASSERT_EQ("part2-body", "BODY2", extractContents(p.getBody()->getPartAt(1)->getBody()->getContents()));

+ }

+

+ void testParseGuessBoundaryWithTransportPadding() {

+

+ // Boundary is not specified in "Content-Type" field

+ // Parser will try to guess it from message contents.

+ // Transport padding white spaces should be ignored.

+

+ vmime::string str =

+ "Content-Type: multipart/mixed"

+ "\r\n\r\n"

+ "--UNKNOWN-BOUNDARY \t \r\nHEADER1\r\n\r\nBODY1\r\n"

+ "--UNKNOWN-BOUNDARY\r\nHEADER2\r\n\r\nBODY2\r\n"

+ "--UNKNOWN-BOUNDARY--";

+

+ vmime::bodyPart p;

+ p.parse(str);

+

+ VASSERT_EQ("count", 2, p.getBody()->getPartCount());

+

+ VASSERT_EQ("part1-body", "BODY1", extractContents(p.getBody()->getPartAt(0)->getBody()->getContents()));

+ VASSERT_EQ("part2-body", "BODY2", extractContents(p.getBody()->getPartAt(1)->getBody()->getContents()));

+ }

+

+ void testParseVeryBigMessage() {

+

+ // When parsing from a seekable input stream, body contents should not

+ // be kept in memory in a "stringContentHandler" object. Instead, content

+ // should be accessible via a "streamContentHandler" object.

+

+ static const std::string BODY1_BEGIN = "BEGIN1BEGIN1BEGIN1";

+ static const std::string BODY1_LINE = "BODY1BODY1BODY1BODY1BODY1BODY1BODY1BODY1BODY1BODY1BODY1BODY1BODY1";

+ static const std::string BODY1_END = "END1END1";

+ static const unsigned int BODY1_REPEAT = 35000;

+ static const size_t BODY1_LENGTH =

+ BODY1_BEGIN.length() + BODY1_LINE.length() * BODY1_REPEAT + BODY1_END.length();

+

+ static const std::string BODY2_LINE = "BODY2BODY2BODY2BODY2BODY2BODY2BODY2BODY2BODY2BODY2BODY2BODY2BODY2";

+ static const unsigned int BODY2_REPEAT = 20000;

+

+ std::ostringstream oss;

+ oss << "Content-Type: multipart/mixed; boundary=\"MY-BOUNDARY\""

+ << "\r\n\r\n"

+ << "--MY-BOUNDARY\r\n"

+ << "HEADER1\r\n"

+ << "\r\n";

+

+ oss << BODY1_BEGIN;

+

+ for (unsigned int i = 0 ; i < BODY1_REPEAT ; ++i) {

+ oss << BODY1_LINE;

+ }

+

+ oss << BODY1_END;

+

+ oss << "\r\n"

+ << "--MY-BOUNDARY\r\n"

+ << "HEADER2\r\n"

+ << "\r\n";

+

+ for (unsigned int i = 0 ; i < BODY2_REPEAT ; ++i) {

+ oss << BODY2_LINE;

+ }

+

+ oss << "\r\n"

+ << "--MY-BOUNDARY--\r\n";

+

+ vmime::shared_ptr <vmime::utility::inputStreamStringAdapter> is =

+ vmime::make_shared <vmime::utility::inputStreamStringAdapter>(oss.str());

+

+ vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ msg->parse(is, oss.str().length());

+

+ vmime::shared_ptr <vmime::body> body1 = msg->getBody()->getPartAt(0)->getBody();

+ vmime::shared_ptr <const vmime::contentHandler> body1Cts = body1->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", 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", vmime::dynamicCast <const vmime::streamContentHandler>(body2Cts) != NULL);

+ }

+

+ void testParseBoundaryPrefix() {

+ /*

+ * Clients are not supposed to create boundary identifiers that

+ * contain a prefix of another (RFC 2046 section 5.1), but alas

+ * CANCOM FortiMail produces this garbage.

+ */

+ vmime::string str =

+ "Content-Type: multipart/related; boundary=\"--b12\"\r\n"

+ "\r\n"

+ "----b12\r\n"

+ "Content-Type: multipart/alternative; boundary=\"--b12-1\"\r\n"

+ "\r\n"

+ "----b12-1\r\n"

+ "Content-Type: text/plain; charset=utf-8\r\n"

+ "\r\n"

+ "P11\r\n"

+ "----b12-1\r\n"

+ "Content-Type: text/html; charset=utf-8\r\n"

+ "\r\n"

+ "P12\r\n"

+ "----b12-1--\r\n"

+ "----b12\r\n"

+ "\r\n"

+ "P2\r\n"

+ "----b12--\r\n";

+

+ vmime::bodyPart relco;

+ relco.parse(str);

+ auto relbd = relco.getBody();

+ VASSERT_EQ("global-partcount", 2, relbd->getPartCount());

+ auto altbd = relbd->getPartAt(0)->getBody();

+ VASSERT_EQ("part1-partcount", 2, altbd->getPartCount());

+ VASSERT_EQ("part1.1-body", "P11", extractContents(altbd->getPartAt(0)->getBody()->getContents()));

+ VASSERT_EQ("part1.2-body", "P12", extractContents(altbd->getPartAt(1)->getBody()->getContents()));

+ VASSERT_EQ("part2-body", "P2", extractContents(relbd->getPartAt(1)->getBody()->getContents()));

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(bodyTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testGenerate_Text)

+ VMIME_TEST(testGenerate_NonText)

+ VMIME_TEST_LIST_END

+

+ void testGenerate_Text() {

+

+ // RFC-2015: [Quoted-Printable encoding] A line break in a text body,

+ // represented as a CRLF sequence in the text canonical form, must be

+ // represented by a line break which is also a CRLF sequence, in the

+ // Quoted-Printable encoding

+

+ vmime::bodyPart p;

+ 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")

+ );

+

+ VASSERT_EQ(

+ "generate",

+ "Foo =C3=A9=C3=A9\r\n"

+ "=C3=A9 bar\r\n"

+ "baz",

+ p.getBody()->generate()

+ );

+ }

+

+ void testGenerate_NonText() {

+

+ vmime::bodyPart p;

+ 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")

+ );

+

+ VASSERT_EQ(

+ "generate",

+ "Binary=FA=FB=0D=0Adata=0D=0A=0D=0A=FC",

+ p.getBody()->generate()

+ );

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+#include "vmime/charset.hpp"

+#include "vmime/charsetConverter.hpp"

+

+#include "charsetTestSuites.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(charsetFilteredOutputStreamTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testInputBufferUnderflow)

+ VMIME_TEST(testInvalidInput1)

+ VMIME_TEST(testStreamCopy)

+ VMIME_TEST(testOneByteAtTime)

+ VMIME_TEST(testVariableInputChunk)

+ VMIME_TEST_LIST_END

+

+

+ void testInputBufferUnderflow() {

+

+ vmime::shared_ptr <vmime::charsetConverter> cc =

+ vmime::charsetConverter::create("utf-8", "iso-8859-1");

+

+ vmime::string output;

+ vmime::utility::outputStreamStringAdapter os(output);

+ vmime::shared_ptr <vmime::utility::filteredOutputStream> cfos = cc->getFilteredOutputStream(os);

+

+ VASSERT_NOT_NULL("filteredOutputStream availability", cfos);

+

+ // føo = 66 c3 b8 6f [UTF8]

+ // føo = 66 f8 6f [latin1]

+

+ cfos->write("\x66\xc3", 2);

+

+ // Incomplete UTF-8 sequence was not converted

+ VASSERT_EQ("chunk 1", toHex("f"), toHex(output));

+

+ // Write second byte of UTF-8 sequence

+ cfos->write("\xb8\x6f", 2);

+

+ VASSERT_EQ("chunk 2", toHex("f\xf8o"), toHex(output));

+ }

+

+ void testInvalidInput1() {

+

+ vmime::string in("foo\xab\xcd\xef bar");

+ vmime::string expectedOut("foo??? bar");

+

+ vmime::string actualOut;

+ vmime::utility::outputStreamStringAdapter osa(actualOut);

+

+ vmime::shared_ptr <vmime::charsetConverter> conv =

+ vmime::charsetConverter::create(vmime::charset("utf-8"), vmime::charset("iso-8859-1"));

+

+ vmime::shared_ptr <vmime::utility::charsetFilteredOutputStream> os =

+ conv->getFilteredOutputStream(osa);

+

+ VASSERT_NOT_NULL("filteredOutputStream availability", os);

+

+ vmime::utility::inputStreamStringAdapter is(in);

+

+ vmime::byte_t buffer[16];

+

+ for (int i = 0 ; !is.eof() ; ++i)

+ os->write(buffer, is.read(buffer, 1));

+

+ os->flush();

+

+ VASSERT_EQ("1", toHex(expectedOut), toHex(actualOut));

+ }

+

+ // Using 'bufferedStreamCopy'

+ void testStreamCopy() {

+

+ for (unsigned int i = 0 ; i < charsetTestSuitesCount ; ++i) {

+

+ const charsetTestSuiteStruct& entry = charsetTestSuites[i];

+

+ std::ostringstream testName;

+ testName << i << ": " << entry.fromCharset << " -> " << entry.toCharset;

+

+ const unsigned long inLength = (entry.fromLength == 0 ? strlen(entry.fromBytes) : entry.fromLength);

+ vmime::string in(entry.fromBytes, entry.fromBytes + inLength);

+

+ const unsigned long outLength = (entry.toLength == 0 ? strlen(entry.toBytes) : entry.toLength);

+ vmime::string expectedOut(entry.toBytes, entry.toBytes + outLength);

+

+ vmime::string actualOut;

+ vmime::utility::outputStreamStringAdapter osa(actualOut);

+

+ vmime::shared_ptr <vmime::charsetConverter> conv =

+ vmime::charsetConverter::create(entry.fromCharset, entry.toCharset);

+

+ vmime::shared_ptr <vmime::utility::charsetFilteredOutputStream> os =

+ conv->getFilteredOutputStream(osa);

+

+ VASSERT_NOT_NULL("filteredOutputStream availability", os);

+

+ vmime::utility::inputStreamStringAdapter is(in);

+

+ vmime::utility::bufferedStreamCopy(is, *os);

+

+ os->flush();

+

+ VASSERT_EQ(testName.str(), toHex(expectedOut), toHex(actualOut));

+ }

+ }

+

+ // One byte at a time

+ void testOneByteAtTime() {

+

+ for (unsigned int i = 0 ; i < charsetTestSuitesCount ; ++i) {

+

+ const charsetTestSuiteStruct& entry = charsetTestSuites[i];

+

+ std::ostringstream testName;

+ testName << i << ": " << entry.fromCharset << " -> " << entry.toCharset;

+

+ const unsigned long inLength = (entry.fromLength == 0 ? strlen(entry.fromBytes) : entry.fromLength);

+ vmime::string in(entry.fromBytes, entry.fromBytes + inLength);

+

+ const unsigned long outLength = (entry.toLength == 0 ? strlen(entry.toBytes) : entry.toLength);

+ vmime::string expectedOut(entry.toBytes, entry.toBytes + outLength);

+

+ vmime::string actualOut;

+ vmime::utility::outputStreamStringAdapter osa(actualOut);

+

+ vmime::shared_ptr <vmime::charsetConverter> conv =

+ vmime::charsetConverter::create(entry.fromCharset, entry.toCharset);

+

+ vmime::shared_ptr <vmime::utility::charsetFilteredOutputStream> os =

+ conv->getFilteredOutputStream(osa);

+

+ VASSERT_NOT_NULL("filteredOutputStream availability", os);

+

+ vmime::utility::inputStreamStringAdapter is(in);

+

+ vmime::byte_t buffer[16];

+

+ for (int i = 0 ; !is.eof() ; ++i)

+ os->write(buffer, is.read(buffer, 1));

+

+ os->flush();

+

+ VASSERT_EQ(testName.str(), toHex(expectedOut), toHex(actualOut));

+ }

+ }

+

+ // Variable chunks

+ void testVariableInputChunk() {

+

+ for (unsigned int i = 0 ; i < charsetTestSuitesCount ; ++i) {

+

+ const charsetTestSuiteStruct& entry = charsetTestSuites[i];

+

+ std::ostringstream testName;

+ testName << i << ": " << entry.fromCharset << " -> " << entry.toCharset;

+

+ const unsigned long inLength = (entry.fromLength == 0 ? strlen(entry.fromBytes) : entry.fromLength);

+ vmime::string in(entry.fromBytes, entry.fromBytes + inLength);

+

+ const unsigned long outLength = (entry.toLength == 0 ? strlen(entry.toBytes) : entry.toLength);

+ vmime::string expectedOut(entry.toBytes, entry.toBytes + outLength);

+

+ vmime::string actualOut;

+ vmime::utility::outputStreamStringAdapter osa(actualOut);

+

+ vmime::shared_ptr <vmime::charsetConverter> conv =

+ vmime::charsetConverter::create(entry.fromCharset, entry.toCharset);

+

+ vmime::shared_ptr <vmime::utility::charsetFilteredOutputStream> os =

+ conv->getFilteredOutputStream(osa);

+

+ VASSERT_NOT_NULL("filteredOutputStream availability", os);

+

+ vmime::utility::inputStreamStringAdapter is(in);

+

+ vmime::byte_t buffer[16];

+

+ for (int i = 0 ; !is.eof() ; ++i)

+ os->write(buffer, is.read(buffer, (i % 5) + 1));

+

+ os->flush();

+

+ VASSERT_EQ(testName.str(), toHex(expectedOut), toHex(actualOut));

+ }

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include <algorithm>

+

+#include "tests/testUtils.hpp"

+

+#include "charsetTestSuites.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(charsetTest)

+

+ VMIME_TEST_LIST_BEGIN

+ // Test valid input

+ VMIME_TEST(testConvertStringValid)

+ VMIME_TEST(testConvertStreamValid)

+ VMIME_TEST(testEncodingHebrew1255)

+

+ // IDNA

+ VMIME_TEST(testEncodeIDNA)

+ VMIME_TEST(testDecodeIDNA)

+

+ VMIME_TEST(testUTF7Support)

+

+ VMIME_TEST(testReplaceInvalidSequence)

+ VMIME_TEST(testStopOnInvalidSequence)

+

+ VMIME_TEST(testStatus)

+ VMIME_TEST(testStatusWithInvalidSequence)

+

+ VMIME_TEST(testIsValidText)

+ VMIME_TEST_LIST_END

+

+

+ void testConvertStringValid() {

+

+ for (unsigned int i = 0 ; i < charsetTestSuitesCount ; ++i) {

+

+ const charsetTestSuiteStruct& entry = charsetTestSuites[i];

+

+ std::ostringstream testName;

+ testName << i << ": " << entry.fromCharset << " -> " << entry.toCharset;

+

+ const unsigned long inLength = (entry.fromLength == 0 ? strlen(entry.fromBytes) : entry.fromLength);

+ vmime::string in(entry.fromBytes, entry.fromBytes + inLength);

+

+ const unsigned long outLength = (entry.toLength == 0 ? strlen(entry.toBytes) : entry.toLength);

+ vmime::string expectedOut(entry.toBytes, entry.toBytes + outLength);

+

+ vmime::string actualOut;

+

+ vmime::charset::convert

+ (in, actualOut, entry.fromCharset, entry.toCharset);

+

+ VASSERT_EQ(testName.str(), toHex(expectedOut), toHex(actualOut));

+ }

+ }

+

+ void testConvertStreamValid() {

+

+ for (unsigned int i = 0 ; i < charsetTestSuitesCount ; ++i) {

+

+ const charsetTestSuiteStruct& entry = charsetTestSuites[i];

+

+ std::ostringstream testName;

+ testName << i << ": " << entry.fromCharset << " -> " << entry.toCharset;

+

+ const unsigned long inLength = (entry.fromLength == 0 ? strlen(entry.fromBytes) : entry.fromLength);

+ vmime::string in(entry.fromBytes, entry.fromBytes + inLength);

+

+ const unsigned long outLength = (entry.toLength == 0 ? strlen(entry.toBytes) : entry.toLength);

+ vmime::string expectedOut(entry.toBytes, entry.toBytes + outLength);

+

+ vmime::string actualOut;

+ vmime::utility::outputStreamStringAdapter os(actualOut);

+

+ vmime::utility::inputStreamStringAdapter is(in);

+

+ vmime::charset::convert(is, os, entry.fromCharset, entry.toCharset);

+

+ os.flush();

+

+ VASSERT_EQ(testName.str(), toHex(expectedOut), toHex(actualOut));

+ }

+ }

+

+ void testEncodingHebrew1255() {

+

+ // hewbrew string in windows-1255 charset

+ const char data[] = "\xe9\xf9\xf7\xf8\xe9\xf9\xf8\xf7\xe9\xe9\xf9";

+ vmime::word w = vmime::word(data, "windows-1255");

+ vmime::string encoded = w.generate();

+ // less than 60% ascii, base64 received

+ VASSERT_EQ("1", "=?windows-1255?B?6fn3+On5+Pfp6fk=?=", encoded);

+ }

+

+ static const vmime::string convertHelper(

+ const vmime::string& in,

+ const vmime::charset& csrc,

+ const vmime::charset& cdest,

+ const vmime::charsetConverterOptions& opts = vmime::charsetConverterOptions(),

+ vmime::charsetConverter::status* st = NULL

+ ) {

+

+ vmime::shared_ptr <vmime::charsetConverter> conv =

+ vmime::charsetConverter::create(csrc, cdest, opts);

+

+ vmime::string out;

+ conv->convert(in, out, st);

+

+ return out;

+ }

+

+ void testEncodeIDNA() {

+

+ VASSERT_EQ("1", "xn--espaol-zwa", convertHelper("español", "utf-8", "idna"));

+

+ // Tests from ICANN

+ VASSERT_EQ("2.1", "xn--hxajbheg2az3al", convertHelper("παράδειγμα", "utf-8", "idna"));

+ VASSERT_EQ("2.2", "xn--jxalpdlp", convertHelper("δοκιμή", "utf-8", "idna"));

+

+ VASSERT_EQ("3.1", "xn--mgbh0fb", convertHelper("مثال", "utf-8", "idna"));

+ VASSERT_EQ("3.2", "xn--kgbechtv", convertHelper("إختبار", "utf-8", "idna"));

+ }

+

+ void testDecodeIDNA() {

+

+ VASSERT_EQ("1", "español", convertHelper("xn--espaol-zwa", "idna", "utf-8"));

+

+ // Tests from ICANN

+ VASSERT_EQ("2.1", "παράδειγμα", convertHelper("xn--hxajbheg2az3al", "idna", "utf-8"));

+ VASSERT_EQ("2.2", "δοκιμή", convertHelper("xn--jxalpdlp", "idna", "utf-8"));

+

+ VASSERT_EQ("3.1", "مثال", convertHelper("xn--mgbh0fb", "idna", "utf-8"));

+ VASSERT_EQ("3.2", "إختبار", convertHelper("xn--kgbechtv", "idna", "utf-8"));

+ }

+

+ void testUTF7Support() {

+

+ // Ensure UTF-7 is supported, because it is used for IMAP

+ VASSERT_EQ("1", "VMime +- UTF-7 encoding", convertHelper("VMime + UTF-7 encoding", "utf-8", "utf-7"));

+ VASSERT_EQ("2", "f+APg-o", convertHelper("\x66\xc3\xb8\x6f", "utf-8", "utf-7"));

+ }

+

+ void testReplaceInvalidSequence() {

+

+ vmime::charsetConverterOptions opts;

+ opts.silentlyReplaceInvalidSequences = true;

+ opts.invalidSequence = "?";

+

+ vmime::string res = convertHelper(

+ "\x61\xf1\x80\x80\xe1\x80\xc2\x62\x80\x63\x80\xbf\x64",

+ "utf-8", "iso-8859-1", opts

+ );

+

+ // Result should be in the form "a???b?c??d" or "a??????b?c??d"...

+ // Remove consecutive question marks for easier matching.

+ res.erase(std::unique(res.begin(), res.end()), res.end());

+

+ VASSERT_EQ(

+ "Illegal UTF-8 sequence",

+ "a?b?c?d",

+ res

+ );

+ }

+

+ void testStopOnInvalidSequence() {

+

+ vmime::charsetConverterOptions opts;

+ opts.silentlyReplaceInvalidSequences = false;

+

+ VASSERT_THROW(

+ "Illegal UTF-8 sequence",

+ convertHelper("\x61\xf1\x80\x80\xe1\x80\xc2\x62\x80\x63\x80\xbf\x64", "utf-8", "iso-8859-1", opts),

+ vmime::exceptions::illegal_byte_sequence_for_charset

+ );

+ }

+

+ void testStatus() {

+

+ vmime::charsetConverterOptions opts;

+ opts.silentlyReplaceInvalidSequences = false;

+

+ vmime::charsetConverter::status st;

+

+ // 012345 6 7

+ convertHelper("Gwena\xc3\xabl", "utf-8", "iso-8859-1", opts, &st);

+

+ VASSERT_EQ("inputBytesRead", 8, st.inputBytesRead);

+ VASSERT_EQ("outputBytesWritten", 7, st.outputBytesWritten);

+ }

+

+ void testStatusWithInvalidSequence() {

+

+ vmime::charsetConverterOptions opts;

+ opts.silentlyReplaceInvalidSequences = false;

+

+ vmime::charsetConverter::status st;

+

+ try {

+

+ // 01234 5 6789 0 1

+ convertHelper("Fran\xc3\xa7ois\xf1\x80\x65", "utf-8", "iso-8859-1", opts, &st);

+

+ } catch (vmime::exceptions::illegal_byte_sequence_for_charset& e) {

+

+ } catch (...) {

+

+ throw;

+ }

+

+ VASSERT_EQ("inputBytesRead", 9, st.inputBytesRead);

+ VASSERT_EQ("outputBytesWritten", 8, st.outputBytesWritten);

+ }

+

+ void testIsValidText() {

+

+ // Invalid text

+ const vmime::string invalidText("Fran\xc3\xa7ois\xf1\x80\x65");

+ vmime::string::size_type firstInvalidByte;

+

+ VASSERT_EQ("invalid.isValidText", false, vmime::charset("utf-8").isValidText(invalidText, &firstInvalidByte));

+ VASSERT_EQ("invalid.firstInvalidByte", 9, firstInvalidByte);

+

+ // Valid text

+ const vmime::string validText("Gwena\xc3\xabl");

+

+ VASSERT_EQ("valid.isValidText", true, vmime::charset("utf-8").isValidText(validText, &firstInvalidByte));

+ VASSERT_EQ("valid.firstInvalidByte", 8, firstInvalidByte);

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+

+struct charsetTestSuiteStruct {

+

+ const char* fromCharset;

+ const char* toCharset;

+ const char* fromBytes;

+ const unsigned int fromLength;

+ const char* toBytes;

+ const unsigned int toLength;

+};

+

+

+static const charsetTestSuiteStruct charsetTestSuites[] = {

+

+ // Test data 1 (excerpt from http://www.gnu.org)

+ {

+ "gb2312", "utf-8",

+

+ "\xbb\xb6\xd3\xad\xc0\xb4\xb5\xbd\x20\x47\x4e\x55\x20\xb9\xa4\xb3"

+ "\xcc\xb5\xc4\xcd\xf8\xd2\xb3\xcb\xc5\xb7\xfe\xd6\xf7\xbb\xfa\x20"

+ "\x77\x77\x77\x2e\x67\x6e\x75\x2e\x6f\x72\x67\x20\xa1\xa3\x20\x47"

+ "\x4e\x55\x20\xb9\xa4\xb3\xcc\x20\xbf\xaa\xca\xbc\xec\xb6\xd2\xbb"

+ "\xbe\xc5\xb0\xcb\xcb\xc4\xc4\xea\xa3\xac\xd6\xbc\xd4\xda\xb7\xa2"

+ "\xd5\xb9\xd2\xbb\xb8\xf6\xc0\xe0\xcb\xc6\x20\x55\x6e\x69\x78\x20"

+ "\xa3\xac\xc7\xd2\xce\xaa\x20\xd7\xd4\xd3\xc9\xc8\xed\xbc\xfe\x20"

+ "\xb5\xc4\xcd\xea\xd5\xfb\xb2\xd9\xd7\xf7\xcf\xb5\xcd\xb3\xa3\xba"

+ "\x20\x47\x4e\x55\x20\xcf\xb5\xcd\xb3\xa1\xa3\xa3\xa8\x47\x4e\x55"

+ "\x20\xca\xc7\xd3\xc9\xa1\xb0\x47\x4e\x55\x27\x73\x20\x4e\x6f\x74"

+ "\x20\x55\x6e\x69\x78\xa1\xb1\xcb\xf9\xb5\xdd\xbb\xd8\xb6\xa8\xd2"

+ "\xe5\xb3\xf6\xb5\xc4\xca\xd7\xd7\xd6\xc4\xb8\xcb\xf5\xd0\xb4\xd3"

+ "\xef\xa3\xbb\xcb\xfc\xb5\xc4\xb7\xa2\xd2\xf4\xce\xaa\xa1\xb0\x67"

+ "\x75\x68\x2d\x4e\x45\x57\xa1\xb1\xa3\xa9\xa1\xa3\xb8\xf7\xd6\xd6"

+ "\xca\xb9\xd3\xc3\x20\x4c\x69\x6e\x75\x78\x20\xd7\xf7\xce\xaa\xc4"

+ "\xda\xba\xcb\xb5\xc4\x20\x47\x4e\x55\x20\xb2\xd9\xd7\xf7\xcf\xb5"

+ "\xcd\xb3\xd5\xfd\xb1\xbb\xb9\xe3\xb7\xba\xb5\xd8\xca\xb9\xd3\xc3"

+ "\xd6\xf8\xa3\xbb\xcb\xe4\xc8\xbb\xd5\xe2\xd0\xa9\xcf\xb5\xcd\xb3"

+ "\xcd\xa8\xb3\xa3\xb1\xbb\xb3\xc6\xd7\xf7\xce\xaa\xa1\xb0\x4c\x69"

+ "\x6e\x75\x78\xa1\xb1\xa3\xac\xb5\xab\xca\xc7\xcb\xfc\xc3\xc7\xd3"

+ "\xa6\xb8\xc3\xb8\xfc\xbe\xab\xc8\xb7\xb5\xd8\xb1\xbb\xb3\xc6\xce"

+ "\xaa\x20\x47\x4e\x55\x2f\x4c\x69\x6e\x75\x78\x20\xcf\xb5\xcd\xb3"

+ "\x20\xa1\xa3\x0a",

+ 0,

+

+ "\xe6\xac\xa2\xe8\xbf\x8e\xe6\x9d\xa5\xe5\x88\xb0\x20\x47\x4e\x55"

+ "\x20\xe5\xb7\xa5\xe7\xa8\x8b\xe7\x9a\x84\xe7\xbd\x91\xe9\xa1\xb5"

+ "\xe4\xbc\xba\xe6\x9c\x8d\xe4\xb8\xbb\xe6\x9c\xba\x20\x77\x77\x77"

+ "\x2e\x67\x6e\x75\x2e\x6f\x72\x67\x20\xe3\x80\x82\x20\x47\x4e\x55"

+ "\x20\xe5\xb7\xa5\xe7\xa8\x8b\x20\xe5\xbc\x80\xe5\xa7\x8b\xe6\x96"

+ "\xbc\xe4\xb8\x80\xe4\xb9\x9d\xe5\x85\xab\xe5\x9b\x9b\xe5\xb9\xb4"

+ "\xef\xbc\x8c\xe6\x97\xa8\xe5\x9c\xa8\xe5\x8f\x91\xe5\xb1\x95\xe4"

+ "\xb8\x80\xe4\xb8\xaa\xe7\xb1\xbb\xe4\xbc\xbc\x20\x55\x6e\x69\x78"

+ "\x20\xef\xbc\x8c\xe4\xb8\x94\xe4\xb8\xba\x20\xe8\x87\xaa\xe7\x94"

+ "\xb1\xe8\xbd\xaf\xe4\xbb\xb6\x20\xe7\x9a\x84\xe5\xae\x8c\xe6\x95"

+ "\xb4\xe6\x93\x8d\xe4\xbd\x9c\xe7\xb3\xbb\xe7\xbb\x9f\xef\xbc\x9a"

+ "\x20\x47\x4e\x55\x20\xe7\xb3\xbb\xe7\xbb\x9f\xe3\x80\x82\xef\xbc"

+ "\x88\x47\x4e\x55\x20\xe6\x98\xaf\xe7\x94\xb1\xe2\x80\x9c\x47\x4e"

+ "\x55\x27\x73\x20\x4e\x6f\x74\x20\x55\x6e\x69\x78\xe2\x80\x9d\xe6"

+ "\x89\x80\xe9\x80\x92\xe5\x9b\x9e\xe5\xae\x9a\xe4\xb9\x89\xe5\x87"

+ "\xba\xe7\x9a\x84\xe9\xa6\x96\xe5\xad\x97\xe6\xaf\x8d\xe7\xbc\xa9"

+ "\xe5\x86\x99\xe8\xaf\xad\xef\xbc\x9b\xe5\xae\x83\xe7\x9a\x84\xe5"

+ "\x8f\x91\xe9\x9f\xb3\xe4\xb8\xba\xe2\x80\x9c\x67\x75\x68\x2d\x4e"

+ "\x45\x57\xe2\x80\x9d\xef\xbc\x89\xe3\x80\x82\xe5\x90\x84\xe7\xa7"

+ "\x8d\xe4\xbd\xbf\xe7\x94\xa8\x20\x4c\x69\x6e\x75\x78\x20\xe4\xbd"

+ "\x9c\xe4\xb8\xba\xe5\x86\x85\xe6\xa0\xb8\xe7\x9a\x84\x20\x47\x4e"

+ "\x55\x20\xe6\x93\x8d\xe4\xbd\x9c\xe7\xb3\xbb\xe7\xbb\x9f\xe6\xad"

+ "\xa3\xe8\xa2\xab\xe5\xb9\xbf\xe6\xb3\x9b\xe5\x9c\xb0\xe4\xbd\xbf"

+ "\xe7\x94\xa8\xe8\x91\x97\xef\xbc\x9b\xe8\x99\xbd\xe7\x84\xb6\xe8"

+ "\xbf\x99\xe4\xba\x9b\xe7\xb3\xbb\xe7\xbb\x9f\xe9\x80\x9a\xe5\xb8"

+ "\xb8\xe8\xa2\xab\xe7\xa7\xb0\xe4\xbd\x9c\xe4\xb8\xba\xe2\x80\x9c"

+ "\x4c\x69\x6e\x75\x78\xe2\x80\x9d\xef\xbc\x8c\xe4\xbd\x86\xe6\x98"

+ "\xaf\xe5\xae\x83\xe4\xbb\xac\xe5\xba\x94\xe8\xaf\xa5\xe6\x9b\xb4"

+ "\xe7\xb2\xbe\xe7\xa1\xae\xe5\x9c\xb0\xe8\xa2\xab\xe7\xa7\xb0\xe4"

+ "\xb8\xba\x20\x47\x4e\x55\x2f\x4c\x69\x6e\x75\x78\x20\xe7\xb3\xbb"

+ "\xe7\xbb\x9f\x20\xe3\x80\x82\x0a",

+ 0

+ }

+};

+

+static const vmime::size_t charsetTestSuitesCount = sizeof(charsetTestSuites) / sizeof(charsetTestSuites[0]);

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(datetimeTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParse)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST(testCompare)

+ VMIME_TEST_LIST_END

+

+

+ void testParse() {

+

+ struct datetimePair {

+ vmime::string parseBuffer;

+ vmime::datetime result;

+ };

+

+ // Here, we can't test all the possible structures for date/time,

+ // so we test some cases. Don't forget to add a new test case

+ // each time you encounter a bug in date/time parsing (after

+ // you have fixed it).

+ datetimePair pairs[] = {

+

+ { /* 1 */ "Mon, 8 Nov 2004 13:42:56 +0000 (GMT)",

+ vmime::datetime(2004, 11, 8, 13, 42, 56, vmime::datetime::GMT) },

+

+ { /* 2 */ "Sun, 7 Nov 2004 00:43:22 -0500 (EST)",

+ vmime::datetime(2004, 11, 7, 0, 43, 22, vmime::datetime::GMT_5) },

+

+ { /* 3 */ "Thu Nov 18 12:11:16 2004",

+ vmime::datetime(vmime::datetime::now().getYear(), 11, 18, 12, 11, 16, vmime::datetime::GMT) },

+

+ { /* 4 */ "Sat, 18, 2004 22:36:32 -0400",

+ vmime::datetime(2004, 1, 18, 22, 36, 32, vmime::datetime::GMT_4) },

+

+ { /* 5 */ "Mon Dec 13 21:57:18 2004",

+ vmime::datetime(vmime::datetime::now().getYear(), 12, 13, 21, 57, 18, vmime::datetime::GMT) },

+

+ { /* 6 */ "18 Nov 2004 21:44:54 +0300",

+ vmime::datetime(2004, 11, 18, 21, 44, 54, vmime::datetime::GMT3) }

+ };

+

+ for (unsigned int i = 0 ; i < sizeof(pairs) / sizeof(pairs[0]) ; ++i) {

+

+ vmime::datetime d;

+ d.parse(pairs[i].parseBuffer);

+

+ std::ostringstream oss;

+ oss << (i + 1);

+

+ VASSERT_EQ(oss.str(), pairs[i].result, d);

+ }

+ }

+

+ void testGenerate() {

+

+ vmime::datetime d1(2005, 7, 8, 4, 5, 6, 1 * 60 + 23);

+

+ VASSERT_EQ("1", "Fri, 8 Jul 2005 04:05:06 +0123", d1.generate());

+ }

+

+ void testCompare() {

+

+ // Date1 = Date2

+ vmime::datetime d1(2005, 4, 22, 14, 6, 0, vmime::datetime::GMT2);

+ vmime::datetime d2(2005, 4, 22, 10, 6, 0, vmime::datetime::GMT_2);

+

+ VASSERT_EQ("1.1", true, d1 == d2);

+ VASSERT_EQ("1.2", false, d1 != d2);

+ VASSERT_EQ("1.3", true, d1 <= d2);

+ VASSERT_EQ("1.4", false, d1 < d2);

+ VASSERT_EQ("1.5", true, d1 >= d2);

+ VASSERT_EQ("1.6", false, d1 > d2);

+

+ // Date1 < Date2

+ vmime::datetime d3(2005, 4, 22, 14, 6, 0);

+ vmime::datetime d4(2005, 4, 22, 15, 6, 0);

+

+ VASSERT_EQ("2.1", false, d3 == d4);

+ VASSERT_EQ("2.2", true, d3 != d4);

+ VASSERT_EQ("2.3", true, d3 <= d4);

+ VASSERT_EQ("2.4", true, d3 < d4);

+ VASSERT_EQ("2.5", false, d3 >= d4);

+ VASSERT_EQ("2.6", false, d3 > d4);

+

+ // Date1 > Date2

+ vmime::datetime d5(2005, 4, 22, 15, 6, 0);

+ vmime::datetime d6(2005, 4, 22, 14, 6, 0);

+

+ VASSERT_EQ("3.1", false, d5 == d6);

+ VASSERT_EQ("3.2", true, d5 != d6);

+ VASSERT_EQ("3.3", false, d5 <= d6);

+ VASSERT_EQ("3.4", false, d5 < d6);

+ VASSERT_EQ("3.5", true, d5 >= d6);

+ VASSERT_EQ("3.6", true, d5 > d6);

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(dispositionTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParse)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST(testModifiers)

+ VMIME_TEST_LIST_END

+

+

+ void testParse() {

+

+ // disposition-mode ";" disposition-type

+ // [ "/" disposition-modifier *( "," disposition-modifier ) ]

+ //

+ // disposition-mode = action-mode "/" sending-mode

+

+ vmime::disposition disp1;

+ disp1.parse("mode");

+

+ VASSERT_EQ("1.1", "mode", disp1.getActionMode());

+ VASSERT_EQ("1.2", "", disp1.getSendingMode());

+ VASSERT_EQ("1.3", "", disp1.getType());

+ VASSERT_EQ("1.4", 0, static_cast <int>(disp1.getModifierList().size()));

+

+ vmime::disposition disp2;

+ disp2.parse("amode/smode");

+

+ VASSERT_EQ("2.1", "amode", disp2.getActionMode());

+ VASSERT_EQ("2.2", "smode", disp2.getSendingMode());

+ VASSERT_EQ("2.3", "", disp2.getType());

+ VASSERT_EQ("2.4", 0, static_cast <int>(disp2.getModifierList().size()));

+

+ vmime::disposition disp3;

+ disp3.parse("amode/smode;type");

+

+ VASSERT_EQ("3.1", "amode", disp3.getActionMode());

+ VASSERT_EQ("3.2", "smode", disp3.getSendingMode());

+ VASSERT_EQ("3.3", "type", disp3.getType());

+ VASSERT_EQ("3.4", 0, static_cast <int>(disp3.getModifierList().size()));

+

+ vmime::disposition disp4;

+ disp4.parse("amode/smode;type/modif");

+

+ VASSERT_EQ("4.1", "amode", disp4.getActionMode());

+ VASSERT_EQ("4.2", "smode", disp4.getSendingMode());

+ VASSERT_EQ("4.3", "type", disp4.getType());

+ VASSERT_EQ("4.4", 1, static_cast <int>(disp4.getModifierList().size()));

+ VASSERT_EQ("4.5", "modif", disp4.getModifierList()[0]);

+

+ vmime::disposition disp5;

+ disp5.parse("amode/smode;type/modif1,modif2");

+

+ VASSERT_EQ("5.1", "amode", disp5.getActionMode());

+ VASSERT_EQ("5.2", "smode", disp5.getSendingMode());

+ VASSERT_EQ("5.3", "type", disp5.getType());

+ VASSERT_EQ("5.4", 2, static_cast <int>(disp5.getModifierList().size()));

+ VASSERT_EQ("5.5", "modif1", disp5.getModifierList()[0]);

+ VASSERT_EQ("5.6", "modif2", disp5.getModifierList()[1]);

+ }

+

+ void testGenerate() {

+

+ vmime::disposition disp;

+

+ VASSERT_EQ("1", "automatic-action/MDN-sent-automatically;displayed", disp.generate());

+

+ disp.setActionMode("amode");

+

+ VASSERT_EQ("2", "amode/MDN-sent-automatically;displayed", disp.generate());

+

+ disp.setActionMode("amode");

+ disp.setSendingMode("smode");

+

+ VASSERT_EQ("3", "amode/smode;displayed", disp.generate());

+

+ disp.setType("type");

+

+ VASSERT_EQ("4", "amode/smode;type", disp.generate());

+

+ disp.addModifier("modif1");

+

+ VASSERT_EQ("5", "amode/smode;type/modif1", disp.generate());

+

+ disp.addModifier("modif2");

+

+ VASSERT_EQ("6", "amode/smode;type/modif1,modif2", disp.generate());

+ }

+

+ void testModifiers() {

+

+ vmime::disposition disp1;

+

+ VASSERT_EQ("1", false, disp1.hasModifier("foo"));

+ VASSERT_EQ("2", 0, static_cast <int>(disp1.getModifierList().size()));

+

+ disp1.addModifier("bar");

+

+ VASSERT_EQ("3", false, disp1.hasModifier("foo"));

+ VASSERT_EQ("4", true, disp1.hasModifier("bar"));

+ VASSERT_EQ("5", 1, static_cast <int>(disp1.getModifierList().size()));

+

+ disp1.addModifier("plop");

+

+ VASSERT_EQ("6", false, disp1.hasModifier("foo"));

+ VASSERT_EQ("7", true, disp1.hasModifier("bar"));

+ VASSERT_EQ("8", true, disp1.hasModifier("plop"));

+ VASSERT_EQ("9", 2, static_cast <int>(disp1.getModifierList().size()));

+

+ disp1.removeModifier("bar");

+

+ VASSERT_EQ("10", false, disp1.hasModifier("foo"));

+ VASSERT_EQ("11", false, disp1.hasModifier("bar"));

+ VASSERT_EQ("12", true, disp1.hasModifier("plop"));

+ VASSERT_EQ("13", 1, static_cast <int>(disp1.getModifierList().size()));

+

+ disp1.removeModifier("PlOp");

+

+ VASSERT_EQ("14", false, disp1.hasModifier("foo"));

+ VASSERT_EQ("15", false, disp1.hasModifier("bar"));

+ VASSERT_EQ("16", false, disp1.hasModifier("plop"));

+ VASSERT_EQ("17", 0, static_cast <int>(disp1.getModifierList().size()));

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+#include "vmime/platform.hpp"

+

+#include <locale>

+#include <clocale>

+

+

+VMIME_TEST_SUITE_BEGIN(emailAddressTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParseASCII)

+ VMIME_TEST(testParseEAI)

+ VMIME_TEST(testParseInvalid)

+ VMIME_TEST(testGenerateASCII)

+ VMIME_TEST(testGenerateEAI)

+ VMIME_TEST(testParseSpecialChars)

+ VMIME_TEST(testParseCommentInLocalPart)

+ VMIME_TEST(testParseCommentInDomainPart)

+ VMIME_TEST(testParseRFC2047EncodedLocalPart)

+ VMIME_TEST(testGenerateSpecialChars)

+ VMIME_TEST_LIST_END

+

+

+ void setUp() {

+

+ // Set the global C and C++ locale to the user-configured locale.

+ // The locale should use UTF-8 encoding for these tests to run successfully.

+ try {

+ std::locale::global(std::locale(""));

+ } catch (std::exception &) {

+ std::setlocale(LC_ALL, "");

+ }

+ }

+

+ void tearDown() {

+

+ // Restore default locale

+ std::locale::global(std::locale("C"));

+ }

+

+

+ void testParseASCII() {

+

+ vmime::emailAddress eml1("local@domain");

+ VASSERT_EQ("1/local", "local", eml1.getLocalName());

+ VASSERT_EQ("1/domain", "domain", eml1.getDomainName());

+

+ // When not specified, domain should be local host name

+ vmime::emailAddress eml2("local");

+ VASSERT_EQ("2/local", "local", eml2.getLocalName());

+ VASSERT_EQ("2/domain", vmime::platform::getHandler()->getHostName(), eml2.getDomainName());

+ }

+

+ void testParseEAI() {

+

+ // Examples taken from Wikipedia (http://en.wikipedia.org/wiki/Email_address)

+

+ // Latin Alphabet (with diacritics):

+ vmime::emailAddress eml1("Pelé@example.com");

+ VASSERT_EQ("1/local", "Pelé", eml1.getLocalName());

+ VASSERT_EQ("1/domain", "example.com", eml1.getDomainName());

+

+ // Greek Alphabet

+ vmime::emailAddress eml2("δοκιμή@παράδειγμα.δοκιμή");

+ VASSERT_EQ("2/local", "δοκιμή", eml2.getLocalName());

+ VASSERT_EQ("2/domain", "παράδειγμα.δοκιμή", eml2.getDomainName());

+

+ // Japanese Characters

+ vmime::emailAddress eml3("甲斐@黒川.日本");

+ VASSERT_EQ("3/local", "甲斐", eml3.getLocalName());

+ VASSERT_EQ("3/domain", "黒川.日本", eml3.getDomainName());

+

+ // Cyrillic Characters

+ vmime::emailAddress eml4("чебурашка@ящик-с-апельсинами.рф");

+ VASSERT_EQ("4/local", "чебурашка", eml4.getLocalName());

+ VASSERT_EQ("4/domain", "ящик-с-апельсинами.рф", eml4.getDomainName());

+ }

+

+ void testParseInvalid() {

+

+ // Only one @ is allowed outside quotation marks

+ vmime::emailAddress eml1("local@part@domain");

+ VASSERT_EQ("1/local", "local", eml1.getLocalName());

+ VASSERT_EQ("1/domain", "part@domain", eml1.getDomainName());

+

+ // Quoted strings must be dot separated, or the only element making up

+ // the local-part: should be parsed correctly, but it still represents

+ // an invalid email address

+ vmime::emailAddress eml2("Just\"not\"right@example.com");

+ VASSERT_EQ("2/local", "Just\"not\"right", eml2.getLocalName());

+ VASSERT_EQ("2/domain", "example.com", eml2.getDomainName());

+

+ // An @ character must separate the local and domain parts

+ vmime::emailAddress eml3("Abc.example.com");

+ VASSERT_EQ("3/local", "Abc.example.com", eml3.getLocalName());

+ VASSERT_EQ("3/domain", vmime::platform::getHandler()->getHostName(), eml3.getDomainName());

+

+ // Whitespace must be escaped

+ vmime::emailAddress eml4("local part@domain");

+ VASSERT_EQ("4/local", "local", eml4.getLocalName());

+ VASSERT_EQ("4/domain", vmime::platform::getHandler()->getHostName(), eml4.getDomainName());

+

+ vmime::emailAddress eml5("this\\ still\\\"not\\\\allowed@example.com");

+ VASSERT_EQ("5/local", "this\\", eml5.getLocalName());

+ VASSERT_EQ("5/domain", vmime::platform::getHandler()->getHostName(), eml5.getDomainName());

+ }

+

+ void testParseSpecialChars() {

+

+ // Examples taken from Wikipedia (http://en.wikipedia.org/wiki/Email_address)

+

+ vmime::emailAddress eml1("\" \"@example.org");

+ VASSERT_EQ("1/local", " ", eml1.getLocalName());

+ VASSERT_EQ("1/domain", "example.org", eml1.getDomainName());

+

+ vmime::emailAddress eml2("\"()<>[]:,;@\\\\\\\"!#$%&'*+-/=?^_`{}| ~.a\"@example.org");

+ VASSERT_EQ("2/local", "()<>[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a", eml2.getLocalName());

+ VASSERT_EQ("3/domain", "example.org", eml2.getDomainName());

+

+ vmime::emailAddress eml3("!#$%&'*+-/=?^_`{}|~@example.org");

+ VASSERT_EQ("3/local", "!#$%&'*+-/=?^_`{}|~", eml3.getLocalName());

+ VASSERT_EQ("3/domain", "example.org", eml3.getDomainName());

+

+ vmime::emailAddress eml4("!#$%&'*+-/=?^_`{}|~@example.org");

+ VASSERT_EQ("4/local", "!#$%&'*+-/=?^_`{}|~", eml4.getLocalName());

+ VASSERT_EQ("4/domain", "example.org", eml4.getDomainName());

+

+ vmime::emailAddress eml5("\"very.unusual.@.unusual.com\"@example.com");

+ VASSERT_EQ("5/local", "very.unusual.@.unusual.com", eml5.getLocalName());

+ VASSERT_EQ("5/domain", "example.com", eml5.getDomainName());

+

+ vmime::emailAddress eml6("\"very.(),:;<>[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com");

+ VASSERT_EQ("6/local", "very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual", eml6.getLocalName());

+ VASSERT_EQ("6/domain", "strange.example.com", eml6.getDomainName());

+ }

+

+ void testParseCommentInLocalPart() {

+

+ vmime::emailAddress eml1("john.smith(comment)@example.com");

+ VASSERT_EQ("1/local", "john.smith", eml1.getLocalName());

+ VASSERT_EQ("1/domain", "example.com", eml1.getDomainName());

+

+ vmime::emailAddress eml2("(comment)john.smith@example.com");

+ VASSERT_EQ("2/local", "john.smith", eml2.getLocalName());

+ VASSERT_EQ("2/domain", "example.com", eml2.getDomainName());

+

+ vmime::emailAddress eml3("(comment (comment in comment))john.smith@example.com");

+ VASSERT_EQ("3/local", "john.smith", eml3.getLocalName());

+ VASSERT_EQ("3/domain", "example.com", eml3.getDomainName());

+

+ vmime::emailAddress eml4("(comment \\) end comment)john.smith@example.com");

+ VASSERT_EQ("4/local", "john.smith", eml4.getLocalName());

+ VASSERT_EQ("4/domain", "example.com", eml4.getDomainName());

+ }

+

+ void testParseCommentInDomainPart() {

+

+ vmime::emailAddress eml1("john.smith@(comment)example.com");

+ VASSERT_EQ("1/local", "john.smith", eml1.getLocalName());

+ VASSERT_EQ("1/domain", "example.com", eml1.getDomainName());

+

+ vmime::emailAddress eml2("john.smith@example.com(comment)");

+ VASSERT_EQ("2/local", "john.smith", eml2.getLocalName());

+ VASSERT_EQ("2/domain", "example.com", eml2.getDomainName());

+

+ vmime::emailAddress eml3("john.smith@(comment (comment in comment))example.com");

+ VASSERT_EQ("3/local", "john.smith", eml3.getLocalName());

+ VASSERT_EQ("3/domain", "example.com", eml3.getDomainName());

+

+ vmime::emailAddress eml4("john.smith@(comment \\) end comment)example.com");

+ VASSERT_EQ("4/local", "john.smith", eml4.getLocalName());

+ VASSERT_EQ("4/domain", "example.com", eml4.getDomainName());

+ }

+

+ void testParseRFC2047EncodedLocalPart() {

+

+ vmime::emailAddress eml1("=?utf-8?Q?Pel=C3=A9?=@example.com");

+ VASSERT_EQ("1/local", "Pelé", eml1.getLocalName());

+ VASSERT_EQ("1/domain", "example.com", eml1.getDomainName());

+

+ vmime::emailAddress eml2("=?utf-8?B?55Sy5paQ?=@xn--5rtw95l.xn--wgv71a");

+ VASSERT_EQ("2/local", "甲斐", eml2.getLocalName());

+ VASSERT_EQ("2/domain", "黒川.日本", eml2.getDomainName());

+

+ vmime::emailAddress eml3("=?utf-8?B?55Sy5paQ?=@xn--5rtw95l.com");

+ VASSERT_EQ("3/local", "甲斐", eml3.getLocalName());

+ VASSERT_EQ("3/domain", "黒川.com", eml3.getDomainName());

+ }

+

+ void testGenerateASCII() {

+

+ VASSERT_EQ(

+ "email 1", "local@domain",

+ vmime::emailAddress("local", "domain").generate()

+ );

+ VASSERT_EQ(

+ "email 2", "=?utf-8?Q?Pel=C3=A9?=@example.com",

+ vmime::emailAddress("Pelé", "example.com").generate()

+ );

+ VASSERT_EQ(

+ "email 3", "=?utf-8?B?55Sy5paQ?=@xn--5rtw95l.xn--wgv71a",

+ vmime::emailAddress("甲斐", "黒川.日本").generate()

+ );

+ VASSERT_EQ(

+ "email 4", "mailtest@xn--r8jz45g.xn--zckzah",

+ vmime::emailAddress("mailtest", "例え.テスト").generate()

+ );

+ VASSERT_EQ(

+ "email 5", "mailtest@xn--mgbh0fb.xn--kgbechtv",

+ vmime::emailAddress("mailtest", "مثال.إختبار").generate()

+ );

+ }

+

+ void testGenerateEAI() {

+

+ vmime::generationContext ctx(vmime::generationContext::getDefaultContext());

+ ctx.setInternationalizedEmailSupport(true);

+

+ vmime::generationContext::switcher <vmime::generationContext> contextSwitcher(ctx);

+

+ VASSERT_EQ(

+ "email 1", "Pelé@example.com",

+ vmime::emailAddress("Pelé", "example.com").generate()

+ );

+ VASSERT_EQ(

+ "email 2", "δοκιμή@παράδειγμα.δοκιμή",

+ vmime::emailAddress("δοκιμή", "παράδειγμα.δοκιμή").generate()

+ );

+ VASSERT_EQ(

+ "email 3", "甲斐@黒川.日本",

+ vmime::emailAddress("甲斐", "黒川.日本").generate()

+ );

+ VASSERT_EQ(

+ "email 4", "чебурашка@ящик-с-апельсинами.рф",

+ vmime::emailAddress("чебурашка", "ящик-с-апельсинами.рф").generate()

+ );

+ }

+

+ void testGenerateSpecialChars() {

+

+ VASSERT_EQ(

+ "email 1", "\"very.unusual.@.unusual.com\"@example.com",

+ vmime::emailAddress("very.unusual.@.unusual.com", "example.com").generate()

+ );

+

+ VASSERT_EQ(

+ "email 2", "\"very.(),:;<>[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com",

+ vmime::emailAddress("very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual", "strange.example.com").generate()

+ );

+

+ VASSERT_EQ(

+ "email 3", "\" \"@example.com",

+ vmime::emailAddress(" ", "example.com").generate()

+ );

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+#include "vmime/utility/outputStreamAdapter.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(emptyContentHandlerTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testIsEmpty)

+ VMIME_TEST(testGetLength)

+ VMIME_TEST(testIsEncoded)

+ VMIME_TEST(testExtract)

+ VMIME_TEST(testExtractRaw)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST_LIST_END

+

+

+ void testIsEmpty() {

+

+ vmime::emptyContentHandler cth;

+

+ VASSERT_TRUE("empty", cth.isEmpty());

+ }

+

+ void testGetLength() {

+

+ vmime::emptyContentHandler cth;

+

+ VASSERT_EQ("length", 0, cth.getLength());

+ }

+

+ void testIsEncoded() {

+

+ vmime::emptyContentHandler cth;

+

+ VASSERT_FALSE("encoded", cth.isEncoded());

+ VASSERT_EQ("encoding", vmime::contentHandler::NO_ENCODING, cth.getEncoding());

+ }

+

+ void testExtract() {

+

+ vmime::emptyContentHandler cth;

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.extract(osa);

+

+ VASSERT_EQ("extract", "", oss.str());

+ }

+

+ void testExtractRaw() {

+

+ vmime::emptyContentHandler cth;

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.extractRaw(osa);

+

+ VASSERT_EQ("extractRaw", "", oss.str());

+ }

+

+ void testGenerate() {

+

+ vmime::emptyContentHandler cth;

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.generate(osa, vmime::encoding("base64"));

+

+ VASSERT_EQ("generate", "", oss.str());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+#include "vmime/utility/outputStreamAdapter.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(fileContentHandlerTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testIsEmpty)

+ VMIME_TEST(testGetLength)

+ VMIME_TEST(testIsEncoded)

+ VMIME_TEST(testExtract)

+ VMIME_TEST(testExtractRaw)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST_LIST_END

+

+

+ vmime::shared_ptr <vmime::utility::file> testFile;

+ vmime::string testDataEncoded, testDataDecoded;

+

+

+ void setUp() {

+

+ testDataDecoded = "ABCDEFGHIJKLMNOPQRSTUVWXYZ \x12\x34\x56\x78\x90 abcdefghijklmnopqrstuvwxyz0123456789";

+ testDataEncoded = "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogEjRWeJAgYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5";

+

+ std::ostringstream testFilePath;

+ testFilePath << "/tmp/vmime_test_" << (rand() % 999999999);

+

+ vmime::shared_ptr <vmime::utility::fileSystemFactory> fsf =

+ vmime::platform::getHandler()->getFileSystemFactory();

+

+ testFile = fsf->create(fsf->stringToPath(testFilePath.str()));

+ testFile->createFile();

+ testFile->getFileWriter()->getOutputStream()->write(testDataEncoded.data(), testDataEncoded.length());

+ }

+

+ void tearDown() {

+

+ testFile->remove();

+ testFile = vmime::null;

+ }

+

+

+ void testIsEmpty() {

+

+ vmime::fileContentHandler cth;

+

+ VASSERT_TRUE("empty", cth.isEmpty());

+ }

+

+ void testGetLength() {

+

+ vmime::fileContentHandler cth(testFile);

+

+ VASSERT_FALSE("empty", cth.isEmpty());

+ VASSERT_EQ("length", testDataEncoded.length(), cth.getLength());

+ }

+

+ void testIsEncoded() {

+

+ vmime::fileContentHandler cth(testFile, vmime::encoding("base64"));

+

+ VASSERT_TRUE("encoded", cth.isEncoded());

+ VASSERT_EQ("encoding", "base64", cth.getEncoding().generate());

+ }

+

+ void testExtract() {

+

+ vmime::fileContentHandler cth(testFile, vmime::encoding("base64"));

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.extract(osa);

+

+ // Data should be decoded from B64

+ VASSERT_EQ("extract", testDataDecoded, oss.str());

+ }

+

+ void testExtractRaw() {

+

+ vmime::fileContentHandler cth(testFile, vmime::encoding("base64"));

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.extractRaw(osa);

+

+ // Data should not be decoded

+ VASSERT_EQ("extractRaw", testDataEncoded, oss.str());

+ }

+

+ void testGenerate() {

+

+ vmime::fileContentHandler cth(testFile, vmime::encoding("base64"));

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.generate(osa, vmime::encoding("quoted-printable"));

+

+ // Data should be reencoded from B64 to QP

+ VASSERT_EQ(

+ "generate",

+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ =124Vx=90 abcdefghijklmnopqrstuvwxyz0123456789",

+ oss.str()

+ );

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(headerFieldTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testBadValueType)

+ VMIME_TEST(testValueOnNextLine)

+ VMIME_TEST(testStripSpacesAtEnd)

+ VMIME_TEST(testValueWithEmptyLine)

+ VMIME_TEST_LIST_END

+

+

+ void testBadValueType() {

+

+ vmime::shared_ptr <vmime::headerFieldFactory> hfactory =

+ vmime::headerFieldFactory::getInstance();

+

+ // "To" header field accepts values of type "addressList"

+ vmime::shared_ptr <vmime::headerField> to = hfactory->create(vmime::fields::TO);

+

+ VASSERT_THROW(

+ "to",

+ to->setValue(vmime::mailbox("email@vmime.org")),

+ vmime::exceptions::bad_field_value_type

+ );

+

+ // Unregistered header field accepts any value type

+ vmime::shared_ptr <vmime::headerField> custom = hfactory->create("X-MyCustomHeader");

+

+ VASSERT_NO_THROW(

+ "custom/1",

+ custom->setValue(vmime::mailbox("email@vmime.org"))

+ );

+ VASSERT_NO_THROW(

+ "custom/2",

+ custom->setValue(vmime::text("field value text"))

+ );

+ }

+

+ void testValueOnNextLine() {

+

+ vmime::parsingContext ctx;

+

+ const vmime::string buffer = "Field: \r\n\tfield data";

+

+ vmime::shared_ptr <vmime::headerField> hfield =

+ vmime::headerField::parseNext(ctx, buffer, 0, buffer.size());

+

+ 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());

+ }

+

+ void testStripSpacesAtEnd() {

+

+ vmime::parsingContext ctx;

+

+ const vmime::string buffer = "Field: \r\n\tfield data ";

+

+ vmime::shared_ptr <vmime::headerField> hfield =

+ vmime::headerField::parseNext(ctx, buffer, 0, buffer.size());

+

+ 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()));

+ }

+

+ void testValueWithEmptyLine() {

+

+ vmime::parsingContext ctx;

+

+ const vmime::string buffer = "Field: \r\n\tdata1\r\n\tdata2\r\n\t\r\n\tdata3";

+

+ vmime::shared_ptr <vmime::headerField> hfield =

+ vmime::headerField::parseNext(ctx, buffer, 0, buffer.size());

+

+ vmime::shared_ptr <vmime::text> hvalue =

+ hfield->getValue <vmime::text>();

+

+ VASSERT_EQ("Field name", "Field", hfield->getName());

+ VASSERT_EQ("Field value", "data1 data2 data3", hvalue->getWholeBuffer());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(headerTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testHas1)

+ VMIME_TEST(testHas2)

+

+ VMIME_TEST(testAppend1)

+ VMIME_TEST(testAppend2)

+

+ VMIME_TEST(testInsertFieldBefore1)

+ VMIME_TEST(testInsertFieldBefore2)

+

+ VMIME_TEST(testInsertFieldAfter1)

+ VMIME_TEST(testInsertFieldAfter2)

+

+ VMIME_TEST(testReplaceField)

+

+ VMIME_TEST(testRemoveField1)

+ VMIME_TEST(testRemoveField2)

+

+ VMIME_TEST(testRemoveAllFields)

+

+ VMIME_TEST(testgetFieldCount)

+

+ VMIME_TEST(testIsEmpty1)

+ VMIME_TEST(testIsEmpty2)

+

+ VMIME_TEST(testGetFieldAt)

+

+ VMIME_TEST(testGetFieldList1)

+ VMIME_TEST(testGetFieldList2)

+

+ VMIME_TEST(testFind1)

+

+ VMIME_TEST(testFindAllFields1)

+ VMIME_TEST(testFindAllFields2)

+ VMIME_TEST(testFindAllFields3)

+ VMIME_TEST_LIST_END

+

+

+ static const std::string getFieldValue(const vmime::headerField& field) {

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter voss(oss);

+ field.generate(voss);

+

+ return oss.str();

+ }

+

+ // has function tests

+ void testHas1() {

+

+ vmime::header hdr;

+ hdr.parse("From: x\r\nTo: y\r\nTo: z\r\n");

+

+ bool res = hdr.hasField("Z");

+

+ VASSERT_EQ("Value", false, res);

+ }

+

+ void testHas2() {

+

+ vmime::header hdr;

+ hdr.parse("X: x\r\nTo: y\r\nTo: z\r\n");

+

+ bool res = hdr.hasField("To");

+

+ VASSERT_EQ("Value", true, res);

+ }

+

+ // appendField function tests

+ void testAppend1() {

+

+ vmime::header hdr;

+ hdr.parse("");

+

+ vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("A", "a");

+ hdr.appendField(hf);

+

+ 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]));

+ }

+

+ void testAppend2() {

+

+ vmime::header hdr;

+ hdr.parse("A: a\r\n");

+

+ vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");

+ hdr.appendField(hf);

+

+ 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]));

+ VASSERT_EQ("Second value", "B: b", headerTest::getFieldValue(*res[1]));

+ }

+

+ // insertFieldBefore

+ void testInsertFieldBefore1() {

+

+ vmime::header hdr;

+ hdr.parse("A: a\r\nC: c\r\n");

+

+ vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");

+ hdr.insertFieldBefore(hdr.getField("C"), hf);

+

+ 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]));

+ VASSERT_EQ("Second value", "B: b", headerTest::getFieldValue(*res[1]));

+ VASSERT_EQ("Third value", "C: c", headerTest::getFieldValue(*res[2]));

+ }

+

+ void testInsertFieldBefore2() {

+

+ vmime::header hdr;

+ hdr.parse("A: a\r\nC: c\r\n");

+

+ vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");

+ hdr.insertFieldBefore(1, hf);

+

+ 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]));

+ VASSERT_EQ("Second value", "B: b", headerTest::getFieldValue(*res[1]));

+ VASSERT_EQ("Third value", "C: c", headerTest::getFieldValue(*res[2]));

+ }

+

+ // insertFieldAfter

+ void testInsertFieldAfter1() {

+

+ vmime::header hdr;

+ hdr.parse("A: a\r\nC: c\r\n");

+

+ vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");

+ hdr.insertFieldAfter(hdr.getField("A"), hf);

+

+ 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]));

+ VASSERT_EQ("Second value", "B: b", headerTest::getFieldValue(*res[1]));

+ VASSERT_EQ("Third value", "C: c", headerTest::getFieldValue(*res[2]));

+ }

+

+ void testInsertFieldAfter2() {

+

+ vmime::header hdr;

+ hdr.parse("A: a\r\nC: c\r\n");

+

+ vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");

+ hdr.insertFieldAfter(0, hf);

+

+ 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]));

+ VASSERT_EQ("Second value", "B: b", headerTest::getFieldValue(*res[1]));

+ VASSERT_EQ("Third value", "C: c", headerTest::getFieldValue(*res[2]));

+ }

+

+ // replaceField

+ void testReplaceField() {

+

+ vmime::header hdr;

+ hdr.parse("A: a\r\nB: b\r\nC: c\r\n");

+

+ vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("Z", "z");

+ hdr.replaceField(hdr.getField("B"), hf);

+

+ 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]));

+ VASSERT_EQ("Second value", "Z: z", headerTest::getFieldValue(*res[1]));

+ VASSERT_EQ("Third value", "C: c", headerTest::getFieldValue(*res[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");

+

+ hdr1.removeField(hdr1.getField("B"));

+ hdr2.removeField(1);

+

+ 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::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]));

+ VASSERT_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");

+

+ hdr1.removeField(hdr1.getField("A"));

+ hdr2.removeField(0);

+

+ std::vector <vmime::shared_ptr <vmime::headerField> > res1 = hdr1.getFieldList();

+ VASSERT_EQ("Count", static_cast <unsigned int>(0), res1.size());

+

+ std::vector <vmime::shared_ptr <vmime::headerField> > res2 = hdr2.getFieldList();

+ VASSERT_EQ("Count", static_cast <unsigned int>(0), res2.size());

+ }

+

+ // 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();

+

+ std::vector <vmime::shared_ptr <vmime::headerField> > res1 = hdr1.getFieldList();

+ VASSERT_EQ("Count", static_cast <unsigned int>(0), res1.size());

+

+ std::vector <vmime::shared_ptr <vmime::headerField> > res2 = hdr2.getFieldList();

+ VASSERT_EQ("Count", static_cast <unsigned int>(0), res2.size());

+ }

+

+ // getFieldCount

+ void testgetFieldCount() {

+

+ vmime::header hdr;

+ hdr.parse("A: a\r\nB: b\r\nC: c\r\nD: d\r\n");

+

+ VASSERT_EQ("Value", 4, hdr.getFieldCount());

+ }

+

+ // isEmpty

+ void testIsEmpty1() {

+

+ vmime::header hdr;

+ hdr.parse("A: a\r\nB: b\r\nC: c\r\n");

+

+ VASSERT_EQ("Value", false, hdr.isEmpty());

+ }

+

+ 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::shared_ptr <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");

+

+ 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]));

+ 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]));

+ }

+

+ void testGetFieldList2() {

+

+ vmime::header hdr;

+ hdr.parse("\r\n");

+

+ std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.getFieldList();

+

+ VASSERT_EQ("Count", static_cast <unsigned int>(0), res.size());

+ }

+

+ // find function tests

+ void testFind1() {

+

+ vmime::header hdr;

+ hdr.parse("A: a\r\nB: b\r\nC: c\r\nB: d\r\n");

+

+ vmime::shared_ptr <vmime::headerField> res = hdr.findField("B");

+

+ VASSERT_EQ("Value", "B: b", getFieldValue(*res));

+ }

+

+ // getAllByName function tests

+ void testFindAllFields1() {

+

+ vmime::header hdr;

+ hdr.parse("A: a1\nC: c1\n");

+

+ std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.findAllFields("B");

+

+ VASSERT_EQ("Count", static_cast <unsigned int>(0), res.size());

+ }

+

+ void testFindAllFields2() {

+

+ vmime::header hdr;

+ hdr.parse("A: a1\nB: b1\nB: b2\nC: c1\n");

+

+ 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]));

+ VASSERT_EQ("Second value", "B: b2", headerTest::getFieldValue(*res[1]));

+ }

+

+ void testFindAllFields3() {

+

+ vmime::header hdr;

+ hdr.parse("A: a1\nB: b1\nB: b2\nC: c1\nC: c3\nC: c2\n");

+

+ 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]));

+ VASSERT_EQ("Second value", "C: c3", headerTest::getFieldValue(*res[1]));

+ VASSERT_EQ("Second value", "C: c2", headerTest::getFieldValue(*res[2]));

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+#include "vmime/htmlTextPart.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(htmlTextPartTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParseText)

+ VMIME_TEST(testParseEmbeddedObjectsCID)

+ VMIME_TEST(testParseEmbeddedObjectsLocation)

+ VMIME_TEST_LIST_END

+

+

+ static const vmime::string extractContent(

+ const vmime::shared_ptr <const vmime::contentHandler>& cth

+ ) {

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth->extract(osa);

+

+ return oss.str();

+ }

+

+

+ void testParseText() {

+

+ const vmime::string msgString = ""

+"MIME-Version: 1.0\r\n"

+"Content-Type: multipart/alternative; boundary=\"LEVEL1\"\r\n"

+"\r\n"

+"--LEVEL1\r\n"

+"Content-Type: text/plain; charset=\"x-ch1\"\r\n"

+"\r\n"

+"Plain text part\r\n"

+"--LEVEL1\r\n"

+"Content-Type: multipart/related; boundary=\"LEVEL2\"\r\n"

+"\r\n"

+"--LEVEL2\r\n"

+"Content-Type: text/html; charset=\"x-ch2\"\r\n"

+"\r\n"

+"<img src=\"cid:image@test\"/>\r\n"

+"--LEVEL2\r\n"

+"Content-Type: image/png; name=\"image.png\"\r\n"

+"Content-Disposition: inline; filename=\"image.png\"\r\n"

+"Content-ID: <image@test>\r\n"

+"\r\n"

+"Image\r\n"

+"--LEVEL2--\r\n"

+"\r\n"

+"--LEVEL1--\r\n"

+"";

+

+ vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ msg->parse(msgString);

+

+ // Sanity checks

+ VASSERT_EQ("part-count1", 2, msg->getBody()->getPartCount());

+ VASSERT_EQ("part-count2", 2, msg->getBody()->getPartAt(1)->getBody()->getPartCount());

+

+ vmime::htmlTextPart htmlPart;

+ htmlPart.parse(msg, msg->getBody()->getPartAt(1),

+ msg->getBody()->getPartAt(1)->getBody()->getPartAt(0));

+

+ VASSERT_EQ("plain", "Plain text part", extractContent(htmlPart.getPlainText()));

+ VASSERT_EQ("html", "<img src=\"cid:image@test\"/>", extractContent(htmlPart.getText()));

+

+ // Should return the charset of the HTML part

+ VASSERT_EQ("charset", "x-ch2", htmlPart.getCharset().generate());

+ }

+

+ /** Test parsing of embedded objects by CID (Content-Id).

+ */

+ void testParseEmbeddedObjectsCID() {

+

+ const vmime::string msgString = ""

+"MIME-Version: 1.0\r\n"

+"Content-Type: multipart/alternative; boundary=\"LEVEL1\"\r\n"

+"\r\n"

+"--LEVEL1\r\n"

+"Content-Type: text/plain; charset=\"x-ch1\"\r\n"

+"\r\n"

+"Plain text part\r\n"

+"--LEVEL1\r\n"

+"Content-Type: multipart/related; boundary=\"LEVEL2\"\r\n"

+"\r\n"

+"--LEVEL2\r\n" // one embedded object before...

+"Content-Type: image/png; name=\"image1.png\"\r\n"

+"Content-Disposition: inline; filename=\"image1.png\"\r\n"

+"Content-ID: <image1@test>\r\n"

+"\r\n"

+"Image1\r\n"

+"--LEVEL2\r\n" // ...the actual text part...

+"Content-Type: text/html; charset=\"x-ch2\"\r\n"

+"\r\n"

+"<img src=\"cid:image1@test\"/>\r\n"

+"<img src=\"CID:image2@test\"/>\r\n"

+"--LEVEL2\r\n" // ...and one after

+"Content-Type: image/jpeg; name=\"image2.jpg\"\r\n"

+"Content-Disposition: inline; filename=\"image2.jpg\"\r\n"

+"Content-ID: <image2@test>\r\n"

+"\r\n"

+"Image2\r\n"

+"--LEVEL2--\r\n"

+"\r\n"

+"--LEVEL1--\r\n"

+"";

+

+ vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ msg->parse(msgString);

+

+ // Sanity checks

+ VASSERT_EQ("part-count1", 2, msg->getBody()->getPartCount());

+ VASSERT_EQ("part-count2", 3, msg->getBody()->getPartAt(1)->getBody()->getPartCount());

+

+ vmime::htmlTextPart htmlPart;

+ htmlPart.parse(

+ msg, msg->getBody()->getPartAt(1),

+ msg->getBody()->getPartAt(1)->getBody()->getPartAt(1)

+ );

+

+ // Two embedded objects should be found.

+ // BUGFIX: "CID:" prefix is not case-sensitive.

+ VASSERT_EQ("count", 2, htmlPart.getObjectCount());

+

+ // Ensure the right objects have been found.

+ VASSERT_EQ("has-obj1", true, htmlPart.hasObject("image1@test"));

+ VASSERT_EQ("has-obj2", true, htmlPart.hasObject("image2@test"));

+

+ // hasObject() should also work with prefixes

+ VASSERT_EQ("has-obj1-pre", true, htmlPart.hasObject("CID:image1@test"));

+ VASSERT_EQ("has-obj2-pre", true, htmlPart.hasObject("cid:image2@test"));

+

+ // Check data in objects

+ vmime::shared_ptr <const vmime::htmlTextPart::embeddedObject> obj;

+

+ obj = htmlPart.findObject("image1@test");

+

+ VASSERT_EQ("ref-type1", vmime::htmlTextPart::embeddedObject::REFERENCED_BY_ID, obj->getReferenceType());

+ VASSERT_EQ("id-obj1", "image1@test", obj->getId());

+ VASSERT_EQ("data-obj1", "Image1", extractContent(obj->getData()));

+ VASSERT_EQ("type-obj1", "image/png", obj->getType().generate());

+

+ obj = htmlPart.findObject("image2@test");

+

+ VASSERT_EQ("ref-type2", vmime::htmlTextPart::embeddedObject::REFERENCED_BY_ID, obj->getReferenceType());

+ VASSERT_EQ("id-obj2", "image2@test", obj->getId());

+ VASSERT_EQ("data-obj2", "Image2", extractContent(obj->getData()));

+ VASSERT_EQ("type-obj2", "image/jpeg", obj->getType().generate());

+ }

+

+ /** Test parsing of embedded objects by location.

+ */

+ void testParseEmbeddedObjectsLocation() {

+

+ const vmime::string msgString = ""

+"MIME-Version: 1.0\r\n"

+"Content-Type: multipart/alternative; boundary=\"LEVEL1\"\r\n"

+"\r\n"

+"--LEVEL1\r\n"

+"Content-Type: text/plain; charset=\"x-ch1\"\r\n"

+"\r\n"

+"Plain text part\r\n"

+"--LEVEL1\r\n"

+"Content-Type: multipart/related; boundary=\"LEVEL2\"\r\n"

+"\r\n"

+"--LEVEL2\r\n"

+"Content-Type: image/png; name=\"image1.png\"\r\n"

+"Content-Location: http://www.vmime.org/test/image1.png\r\n"

+"Content-Disposition: inline; filename=\"image1.png\"\r\n"

+"Content-Id: <image1@test>\r\n"

+"\r\n"

+"Image1\r\n"

+"--LEVEL2\r\n"

+"Content-Type: text/html; charset=\"x-ch2\"\r\n"

+"\r\n"

+"<img src=\"http://www.vmime.org/test/image1.png\"/>\r\n"

+"--LEVEL2--\r\n"

+"\r\n"

+"--LEVEL1--\r\n"

+"";

+

+ vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();

+ msg->parse(msgString);

+

+ // Sanity checks

+ VASSERT_EQ("part-count1", 2, msg->getBody()->getPartCount());

+ VASSERT_EQ("part-count2", 2, msg->getBody()->getPartAt(1)->getBody()->getPartCount());

+

+ vmime::htmlTextPart htmlPart;

+ htmlPart.parse(

+ msg, msg->getBody()->getPartAt(1),

+ msg->getBody()->getPartAt(1)->getBody()->getPartAt(1)

+ );

+

+ // Only one embedded object

+ VASSERT_EQ("count", 1, htmlPart.getObjectCount());

+

+ // Should work only with Content-Location as the Content-Id is

+ // not referenced in the HTML contents

+ VASSERT_EQ("has-obj-loc", true, htmlPart.hasObject("http://www.vmime.org/test/image1.png"));

+ VASSERT_EQ("has-obj-cid", false, htmlPart.hasObject("image1@test"));

+

+ // Check data

+ vmime::shared_ptr <const vmime::htmlTextPart::embeddedObject> obj;

+

+ obj = htmlPart.findObject("http://www.vmime.org/test/image1.png");

+

+ VASSERT_EQ("ref-type", vmime::htmlTextPart::embeddedObject::REFERENCED_BY_LOCATION, obj->getReferenceType());

+ VASSERT_EQ("id-obj", "http://www.vmime.org/test/image1.png", obj->getId());

+ VASSERT_EQ("data-obj", "Image1", extractContent(obj->getData()));

+ VASSERT_EQ("type-obj", "image/png", obj->getType().generate());

+ }

+

+ // TODO: test generation of text parts

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(mailboxGroupTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParseExtraWhitespaces)

+ VMIME_TEST(testParseNoEndDelimiter)

+ VMIME_TEST(testParseExtraChars)

+ VMIME_TEST(testEmptyGroup)

+ VMIME_TEST(testEncodedEmptyGroup)

+ VMIME_TEST_LIST_END

+

+

+ void testParseExtraWhitespaces() {

+

+ vmime::mailboxGroup mgrp;

+ mgrp.parse(" \t group : aaa <aaa@vmime.org>, bbb <bbb@vmime.org>");

+

+ VASSERT_EQ("name", "group", mgrp.getName().getWholeBuffer());

+ VASSERT_EQ("count", 2, mgrp.getMailboxCount());

+

+ VASSERT_EQ("mbox1.email", "aaa@vmime.org", mgrp.getMailboxAt(0)->getEmail());

+ VASSERT_EQ("mbox1.name", "aaa", mgrp.getMailboxAt(0)->getName());

+

+ VASSERT_EQ("mbox2.email", "bbb@vmime.org", mgrp.getMailboxAt(1)->getEmail());

+ VASSERT_EQ("mbox2.name", "bbb", mgrp.getMailboxAt(1)->getName());

+ }

+

+ void testParseNoEndDelimiter() {

+

+ vmime::addressList addrs;

+ addrs.parse("group: aaa <aaa@vmime.org>, bbb <bbb@vmime.org>");

+

+ VASSERT_EQ("count", 1, addrs.getAddressCount());

+ VASSERT_TRUE("is group", addrs.getAddressAt(0)->isGroup());

+

+ 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());

+

+ VASSERT_EQ("mbox1.email", "aaa@vmime.org", mgrp->getMailboxAt(0)->getEmail());

+ VASSERT_EQ("mbox1.name", "aaa", mgrp->getMailboxAt(0)->getName());

+

+ VASSERT_EQ("mbox2.email", "bbb@vmime.org", mgrp->getMailboxAt(1)->getEmail());

+ VASSERT_EQ("mbox2.name", "bbb", mgrp->getMailboxAt(1)->getName());

+ }

+

+ void testParseExtraChars() {

+

+ vmime::mailboxGroup mgrp;

+ mgrp.parse("group: aaa <aaa@vmime.org>, bbb <bbb@vmime.org>; extra chars here...");

+

+ VASSERT_EQ("name", "group", mgrp.getName().getWholeBuffer());

+ VASSERT_EQ("count", 2, mgrp.getMailboxCount());

+

+ VASSERT_EQ("mbox1.email", "aaa@vmime.org", mgrp.getMailboxAt(0)->getEmail());

+ VASSERT_EQ("mbox1.name", "aaa", mgrp.getMailboxAt(0)->getName());

+

+ VASSERT_EQ("mbox2.email", "bbb@vmime.org", mgrp.getMailboxAt(1)->getEmail());

+ VASSERT_EQ("mbox2.name", "bbb", mgrp.getMailboxAt(1)->getName());

+ }

+

+ void testEmptyGroup() {

+

+ vmime::mailboxGroup mgrp;

+ mgrp.parse("Undisclosed recipients:;");

+

+ VASSERT_EQ("name", "Undisclosed recipients", mgrp.getName().getWholeBuffer());

+ VASSERT_EQ("count", 0, mgrp.getMailboxCount());

+ }

+

+ void testEncodedEmptyGroup() {

+

+ vmime::mailboxGroup mgrp;

+ mgrp.parse("=?us-ascii?Q?Undisclosed_recipients?=:;");

+

+ VASSERT_EQ("name", "Undisclosed recipients", mgrp.getName().getWholeBuffer());

+ VASSERT_EQ("count", 0, mgrp.getMailboxCount());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(mailboxListTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParseGroup)

+ VMIME_TEST_LIST_END

+

+

+ // Disposition-Notification-To:: <email@domain.com>

+ void testParseGroup() {

+

+ // Groups should be extracted to multiple mailboxes in mailbox lists

+ vmime::mailboxList mboxList;

+ mboxList.parse("email1@domain1.com, : <email2@domain2.com>, email3@domain3.com");

+

+ VASSERT_EQ("count", 3, mboxList.getMailboxCount());

+ VASSERT_EQ("email", "email1@domain1.com", mboxList.getMailboxAt(0)->getEmail().generate());

+ VASSERT_EQ("email", "email2@domain2.com", mboxList.getMailboxAt(1)->getEmail().generate());

+ VASSERT_EQ("email", "email3@domain3.com", mboxList.getMailboxAt(2)->getEmail().generate());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(mailboxTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParse)

+ VMIME_TEST(testEmptyEmailAddress)

+ VMIME_TEST(testSeparatorInComment)

+ VMIME_TEST(testMalformations)

+ VMIME_TEST(testExcessiveQuoting)

+ VMIME_TEST_LIST_END

+

+

+ void testParse() {

+

+ static const vmime::string testSuitesParse[] = {

+

+ // Test 1

+ "My (this is a comment)name <me(another \\)comment) @ somewhere(else).com>",

+

+ "[address-list: [[mailbox: name=[text: [[word: charset=us-ascii, buffer=My name]]], email=me@somewhere.com]]]",

+

+ // Test 2

+ "mailbox1 <mailbox@one>,;,,, ,, ,,;group1:mailbox1@group1, mailbox2@group2,,\"mailbox #3\" <mailbox3@group2>;, <mailbox@two>,,,,,,,,=?iso-8859-1?q?mailbox_number_3?= <mailbox@three>, =?abc?Q?mailbox?= =?def?Q?_number_4?= <mailbox@four>",

+

+ "[address-list: [[mailbox: name=[text: [[word: charset=us-ascii, buffer=mailbox1]]], email=mailbox@one],[mailbox-group: name=[text: [[word: charset=us-ascii, buffer=group1]]], list=[[mailbox: name=[text: []], email=mailbox1@group1],[mailbox: name=[text: []], email=mailbox2@group2],[mailbox: name=[text: [[word: charset=us-ascii, buffer=mailbox #3]]], email=mailbox3@group2]]],[mailbox: name=[text: []], email=mailbox@two],[mailbox: name=[text: [[word: charset=iso-8859-1, buffer=mailbox number 3]]], email=mailbox@three],[mailbox: name=[text: [[word: charset=abc, buffer=mailbox],[word: charset=def, buffer= number 4]]], email=mailbox@four]]]",

+

+ // Test 3

+ "John Doe <john.doe@acme.com>",

+

+ "[address-list: [[mailbox: name=[text: [[word: charset=us-ascii, buffer=John Doe]]], email=john.doe@acme.com]]]",

+

+ // Test 4

+ "john.doe@acme.com (John Doe)",

+

+ "[address-list: [[mailbox: name=[text: []], email=john.doe@acme.com]]]",

+

+ // Test 5

+ "John.Doe(ignore)@acme.com (John Doe)",

+

+ "[address-list: [[mailbox: name=[text: []], email=John.Doe@acme.com]]]",

+

+ // Test 6

+ "<john.doe@acme.com>",

+

+ "[address-list: [[mailbox: name=[text: []], email=john.doe@acme.com]]]",

+

+ // Test 7

+ "john.doe@acme.com",

+

+ "[address-list: [[mailbox: name=[text: []], email=john.doe@acme.com]]]",

+

+ // Test 8

+ "\"John Doe\" <john.doe@acme.com>",

+

+ "[address-list: [[mailbox: name=[text: [[word: charset=us-ascii, buffer=John Doe]]], email=john.doe@acme.com]]]",

+

+ // Test 9

+ "=?us-ascii?q?John?=<john.doe@acme.com>",

+

+ "[address-list: [[mailbox: name=[text: [[word: charset=us-ascii, buffer=John]]], email=john.doe@acme.com]]]",

+

+ // Test 10

+ "\"John\"<john.doe@acme.com>",

+

+ "[address-list: [[mailbox: name=[text: [[word: charset=us-ascii, buffer=John]]], email=john.doe@acme.com]]]",

+

+ // Test 11

+ "John<john.doe@acme.com>",

+

+ "[address-list: [[mailbox: name=[text: [[word: charset=us-ascii, buffer=John]]], email=john.doe@acme.com]]]"

+ };

+

+ for (unsigned int i = 0 ; i < sizeof(testSuitesParse) / sizeof(testSuitesParse[0]) / 2 ; ++i) {

+

+ vmime::string in = testSuitesParse[i * 2];

+ vmime::string out = testSuitesParse[i * 2 + 1];

+

+ std::ostringstream oss;

+ oss << "Test " << (i + 1);

+

+ vmime::addressList addrList;

+ addrList.parse(in);

+

+ std::ostringstream cmp;

+ cmp << addrList;

+

+ VASSERT_EQ(oss.str(), out, cmp.str());

+ }

+ }

+

+ void testEmptyEmailAddress() {

+

+ vmime::addressList addrList;

+ addrList.parse("\"Full Name\" <>");

+

+ VASSERT_EQ("count", 1, addrList.getAddressCount());

+ VASSERT_EQ("!group", false, addrList.getAddressAt(0)->isGroup());

+

+ 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());

+ }

+

+ void testSeparatorInComment() {

+

+ vmime::addressList addrList;

+ addrList.parse("aaa(comment,comment)@vmime.org, bbb@vmime.org");

+

+ VASSERT_EQ("count", 2, addrList.getAddressCount());

+

+ 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", "aaa@vmime.org", mbox1->getEmail());

+

+ VASSERT_EQ("name2", vmime::text(), mbox2->getName());

+ VASSERT_EQ("email2", "bbb@vmime.org", mbox2->getEmail());

+ }

+

+ void testMalformations() {

+ vmime::mailbox mbox;

+

+ mbox.parse("a@b.c <e@f.g>");

+ VASSERT_EQ("name", vmime::text("a@b.c"), mbox.getName());

+ VASSERT_EQ("email", "e@f.g", mbox.getEmail());

+

+ mbox.parse("a@b.c e@f.g <h@i.j>");

+ VASSERT_EQ("name", vmime::text("a@b.c e@f.g"), mbox.getName());

+ VASSERT_EQ("email", "h@i.j", mbox.getEmail());

+

+ mbox.parse("Foo <bar<baz@quux.com>");

+ VASSERT_EQ("name", vmime::text("Foo <bar"), mbox.getName());

+ VASSERT_EQ("email", "baz@quux.com", mbox.getEmail());

+

+ mbox.parse("Foo <foo@x.com> <bar@x.com>");

+ VASSERT_EQ("name", vmime::text("Foo <foo@x.com>"), mbox.getName());

+ VASSERT_EQ("email", "bar@x.com", mbox.getEmail());

+

+ mbox.parse("Foo <foo@x.com> Bar <bar@y.com>");

+ VASSERT_EQ("name", vmime::text("Foo <foo@x.com> Bar"), mbox.getName());

+ VASSERT_EQ("email", "bar@y.com", mbox.getEmail());

+ }

+

+ void testExcessiveQuoting() {

+ using namespace vmime;

+

+ // Check that ASCII display names are not encoded more than necessary

+ emailAddress e("a@b.com");

+ auto a = make_shared<mailbox>(text(word("Foo B@r", charsets::US_ASCII)), e);

+ VASSERT_EQ("generate", "\"Foo B@r\" <a@b.com>", a->generate());

+ VASSERT_NEQ("generate", "=?utf-8?Q?Foo_B=40r?= <a@b.com>", a->generate());

+

+ a = make_shared<mailbox>(text(word("Foo B@r", charsets::UTF_8)), e);

+ VASSERT_EQ("generate", "=?utf-8?Q?Foo_B=40r?= <a@b.com>", a->generate());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(mediaTypeTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testConstructors)

+ VMIME_TEST(testCopy)

+ VMIME_TEST(testSetFromString)

+ VMIME_TEST(testParse)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST_LIST_END

+

+

+ void testConstructors() {

+

+ vmime::mediaType t1;

+

+ VASSERT_EQ("1.1", vmime::mediaTypes::APPLICATION, t1.getType());

+ VASSERT_EQ("1.2", vmime::mediaTypes::APPLICATION_OCTET_STREAM, t1.getSubType());

+

+ vmime::mediaType t2("type", "sub");

+

+ VASSERT_EQ("2.1", "type", t2.getType());

+ VASSERT_EQ("2.2", "sub", t2.getSubType());

+

+ vmime::mediaType t3("type/sub");

+

+ VASSERT_EQ("3.1", "type", t3.getType());

+ VASSERT_EQ("3.2", "sub", t3.getSubType());

+ }

+

+ void testCopy() {

+

+ vmime::mediaType t1("type/sub");

+

+ VASSERT_EQ("eq1", "type", t1.getType());

+ VASSERT_EQ("eq2", "sub", t1.getSubType());

+

+ VASSERT("operator==", t1 == t1);

+ VASSERT("clone", t1 == *vmime::clone(t1));

+

+ VASSERT_EQ("eq3", "type", vmime::clone(t1)->getType());

+ VASSERT_EQ("eq4", "sub", vmime::clone(t1)->getSubType());

+

+ vmime::mediaType t2;

+ t2.copyFrom(t1);

+

+ VASSERT("copyFrom", t1 == t2);

+ }

+

+ void testSetFromString() {

+

+ vmime::mediaType t1;

+ t1.setFromString("type/sub");

+

+ VASSERT_EQ("1.1", "type", t1.getType());

+ VASSERT_EQ("1.2", "sub", t1.getSubType());

+ }

+

+ void testParse() {

+

+ vmime::mediaType t1;

+ t1.parse("type/sub");

+

+ VASSERT_EQ("1.1", "type", t1.getType());

+ VASSERT_EQ("1.2", "sub", t1.getSubType());

+ }

+

+ void testGenerate() {

+

+ vmime::mediaType t1("type", "sub");

+

+ VASSERT_EQ("1", "type/sub", t1.generate());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(messageIdSequenceTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParse)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST_LIST_END

+

+

+ void testParse() {

+

+ vmime::messageIdSequence s1;

+ s1.parse("");

+

+ VASSERT_EQ("1", 0, s1.getMessageIdCount());

+

+ vmime::messageIdSequence s2;

+ s2.parse(" \t ");

+

+ VASSERT_EQ("2", 0, s2.getMessageIdCount());

+

+ vmime::messageIdSequence s3;

+ s3.parse("<a@b>");

+

+ VASSERT_EQ("3.1", 1, s3.getMessageIdCount());

+ VASSERT_EQ("3.2", "a", s3.getMessageIdAt(0)->getLeft());

+ VASSERT_EQ("3.3", "b", s3.getMessageIdAt(0)->getRight());

+

+ vmime::messageIdSequence s4;

+ s4.parse("<a@b> \r\n\t<c@d>");

+

+ VASSERT_EQ("4.1", 2, s4.getMessageIdCount());

+ VASSERT_EQ("4.2", "a", s4.getMessageIdAt(0)->getLeft());

+ VASSERT_EQ("4.3", "b", s4.getMessageIdAt(0)->getRight());

+ VASSERT_EQ("4.4", "c", s4.getMessageIdAt(1)->getLeft());

+ VASSERT_EQ("4.5", "d", s4.getMessageIdAt(1)->getRight());

+ }

+

+ void testGenerate() {

+

+ vmime::messageIdSequence s1;

+ s1.appendMessageId(vmime::make_shared <vmime::messageId>("a", "b"));

+

+ VASSERT_EQ("1", "<a@b>", s1.generate());

+

+ vmime::messageIdSequence s2;

+ 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());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(messageIdTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParse)

+ VMIME_TEST(testParseInvalid)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST_LIST_END

+

+

+ void testParse() {

+

+ vmime::messageId m1;

+ m1.parse("<a@b>");

+

+ VASSERT_EQ("1.1", "a", m1.getLeft());

+ VASSERT_EQ("1.2", "b", m1.getRight());

+ }

+

+ void testParseInvalid() {

+

+ vmime::messageId m1;

+ m1.parse("foo@bar");

+

+ VASSERT_EQ("1.1", "foo", m1.getLeft());

+ VASSERT_EQ("1.2", "bar", m1.getRight());

+ }

+

+ void testGenerate() {

+

+ vmime::messageId m1;

+

+ VASSERT_EQ("1", "<>", m1.generate());

+

+ vmime::messageId m2;

+ m2.setLeft("a");

+

+ VASSERT_EQ("2", "<a>", m2.generate());

+

+ vmime::messageId m3;

+ m3.setRight("b");

+

+ VASSERT_EQ("3", "<@b>", m3.generate());

+

+ vmime::messageId m4;

+ m4.setLeft("a");

+ m4.setRight("b");

+

+ VASSERT_EQ("4", "<a@b>", m4.generate());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(messageTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testGetGeneratedSize)

+ VMIME_TEST_LIST_END

+

+

+ void testGetGeneratedSize() {

+

+ vmime::generationContext ctx;

+

+ 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::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

+ const vmime::size_t genSize = msg->getGeneratedSize(ctx);

+ const vmime::size_t actualSize = msg->generate().length();

+

+ std::ostringstream oss;

+ oss << "estimated size (" << genSize << ") >= actual size (" << actualSize << ")";

+

+ VASSERT(oss.str(), genSize >= actualSize);

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+#include <locale>

+#include <clocale>

+

+

+VMIME_TEST_SUITE_BEGIN(parameterTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParse)

+ VMIME_TEST(testParseRFC2231)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST(testGetGeneratedSize)

+ VMIME_TEST(testGenerateRFC2231)

+ VMIME_TEST(testGetGeneratedSizeRFC2231)

+ VMIME_TEST(testNonStandardEncodedParam)

+ VMIME_TEST(testParseNonSignificantWS)

+ VMIME_TEST(testEncodeTSpecials)

+ VMIME_TEST(testEncodeTSpecialsInRFC2231)

+ VMIME_TEST(testWhitespaceBreaksTheValue)

+ VMIME_TEST_LIST_END

+

+

+ // HACK: parameterizedHeaderField constructor is private

+ class parameterizedHeaderField : public vmime::parameterizedHeaderField {

+

+ public:

+

+ parameterizedHeaderField() {

+

+ setName("F");

+ setValue(vmime::headerFieldFactory::getInstance()->createValue(getName()));

+ setValue(vmime::word("X"));

+ }

+

+ using vmime::parameterizedHeaderField::generate;

+

+ const vmime::string generate(

+ const vmime::generationContext::EncodedParameterValueModes genMode,

+ const vmime::size_t maxLineLength = 0

+ ) const {

+

+ vmime::generationContext ctx(vmime::generationContext::getDefaultContext());

+ ctx.setEncodedParameterValueMode(genMode);

+

+ if (maxLineLength != 0) {

+ ctx.setMaxLineLength(maxLineLength);

+ }

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter adapter(oss);

+

+ vmime::parameterizedHeaderField::generate(ctx, adapter);

+

+ return oss.str();

+ }

+ };

+

+

+ const vmime::string generateParameter(

+ const vmime::parameter& param,

+ const vmime::generationContext& ctx,

+ const vmime::size_t maxLineLength = 0

+ ) const {

+

+ vmime::generationContext ctx2(ctx);

+

+ if (maxLineLength != 0) {

+ ctx2.setMaxLineLength(maxLineLength);

+ }

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter adapter(oss);

+

+ param.generate(ctx2, adapter);

+

+ return oss.str();

+ }

+

+

+#define FIELD_VALUE(f) (f.getValue()->generate())

+#define PARAM_VALUE(p, n) (p.getParameterAt(n)->getValue().generate())

+#define PARAM_NAME(p, n) (p.getParameterAt(n)->getName())

+#define PARAM_CHARSET(p, n) \

+ (p.getParameterAt(n)->getValue().getCharset().generate())

+#define PARAM_LANG(p, n) \

+ (p.getParameterAt(n)->getValue().getLanguage())

+#define PARAM_BUFFER(p, n) \

+ (p.getParameterAt(n)->getValue().getBuffer())

+

+

+ void setUp() {

+

+ // Set the global C and C++ locale to the user-configured locale.

+ // The locale should use UTF-8 encoding for these tests to run successfully.

+ try {

+ std::locale::global(std::locale(""));

+ } catch (std::exception &) {

+ std::setlocale(LC_ALL, "");

+ }

+ }

+

+ void tearDown() {

+

+ // Restore default locale

+ std::locale::global(std::locale("C"));

+ }

+

+

+ void testParse() {

+

+ // Simple parameter

+ parameterizedHeaderField p1;

+ p1.parse("X; param1=value1;\r\n");

+

+ VASSERT_EQ("1.1", 1, p1.getParameterCount());

+ VASSERT_EQ("1.2", "param1", PARAM_NAME(p1, 0));

+ VASSERT_EQ("1.3", "value1", PARAM_VALUE(p1, 0));

+

+ // Multi-section parameters (1/2)

+ parameterizedHeaderField p2a;

+ p2a.parse(

+ "X; param1=value1;\r\n"

+ " param2*0=\"val\";\r\n"

+ " param2*1=\"ue2\";"

+ );

+

+ VASSERT_EQ("2a.1", 2, p2a.getParameterCount());

+ VASSERT_EQ("2a.2", "param1", PARAM_NAME(p2a, 0));

+ VASSERT_EQ("2a.3", "value1", PARAM_VALUE(p2a, 0));

+ VASSERT_EQ("2a.4", "param2", PARAM_NAME(p2a, 1));

+ VASSERT_EQ("2a.5", "value2", PARAM_VALUE(p2a, 1));

+

+ // Multi-section parameters (2/2)

+ parameterizedHeaderField p2b;

+ p2b.parse(

+ "X; param1=value1;\r\n"

+ " param2=\"should be ignored\";\r\n"

+ " param2*0=\"val\";\r\n"

+ " param2*1=\"ue2\";"

+ );

+

+ VASSERT_EQ("2b.1", 2, p2b.getParameterCount());

+ VASSERT_EQ("2b.2", "param1", PARAM_NAME(p2b, 0));

+ VASSERT_EQ("2b.3", "value1", PARAM_VALUE(p2b, 0));

+ VASSERT_EQ("2b.4", "param2", PARAM_NAME(p2b, 1));

+ VASSERT_EQ("2b.5", "value2", PARAM_VALUE(p2b, 1));

+

+ // Extended parameter (charset and language information)

+ parameterizedHeaderField p3;

+ p3.parse("X; param1*=charset'language'value1;\r\n");

+

+ VASSERT_EQ("3.1", 1, p3.getParameterCount());

+ VASSERT_EQ("3.2", "param1", PARAM_NAME(p3, 0));

+ VASSERT_EQ("3.3", "charset", PARAM_CHARSET(p3, 0));

+ VASSERT_EQ("3.4", "value1", PARAM_BUFFER(p3, 0));

+

+ // Encoded characters in extended parameter values

+ parameterizedHeaderField p4;

+ p4.parse("X; param1*=a%20value%20with%20multiple%20word%73"); // 0x73 = 's'

+

+ VASSERT_EQ("4.1", 1, p4.getParameterCount());

+ VASSERT_EQ("4.2", "param1", PARAM_NAME(p4, 0));

+ VASSERT_EQ("4.3", "a value with multiple words", PARAM_VALUE(p4, 0));

+

+ // Invalid encoded character

+ parameterizedHeaderField p5;

+ p5.parse("X; param1*=test%20value%");

+

+ VASSERT_EQ("5.1", 1, p5.getParameterCount());

+ VASSERT_EQ("5.2", "param1", PARAM_NAME(p5, 0));

+ VASSERT_EQ("5.3", "test value%", PARAM_VALUE(p5, 0));

+

+ // Spaces before and after '='

+ parameterizedHeaderField p6;

+ p6.parse("X; param1\t= \"value1\"");

+

+ VASSERT_EQ("6.1", 1, p6.getParameterCount());

+ VASSERT_EQ("6.2", "param1", PARAM_NAME(p6, 0));

+ VASSERT_EQ("6.3", "value1", PARAM_VALUE(p6, 0));

+

+ // Quoted strings and escaped chars

+ parameterizedHeaderField p7;

+ p7.parse("X; param1=\"this is a slash: \\\"\\\\\\\"\""); // \"\\\"

+

+ VASSERT_EQ("7.1", 1, p7.getParameterCount());

+ VASSERT_EQ("7.2", "param1", PARAM_NAME(p7, 0));

+ VASSERT_EQ("7.3", "this is a slash: \"\\\"", PARAM_VALUE(p7, 0));

+ }

+

+ void testParseRFC2231() {

+

+ // Extended parameter with charset specified in more than one

+ // section (this is forbidden by RFC, but is should not fail)

+ parameterizedHeaderField p1;

+ p1.parse(

+ "X; param1*0*=charset1'language1'value1;\r\n"

+ " param1*1*=charset2'language2'value2;"

+ );

+

+ VASSERT_EQ("1.1", 1, p1.getParameterCount());

+ VASSERT_EQ("1.2", "param1", PARAM_NAME(p1, 0));

+ VASSERT_EQ("1.3", "charset1", PARAM_CHARSET(p1, 0));

+ VASSERT_EQ("1.4", "value1charset2'language2'value2", PARAM_BUFFER(p1, 0));

+

+ // Charset not specified in the first section (that is not encoded),

+ // but specified in the second one (legal)

+ parameterizedHeaderField p2;

+ p2.parse(

+ "X; param1*0=value1;\r\n"

+ " param1*1*=charset'language'value2;"

+ );

+

+ VASSERT_EQ("2.1", 1, p2.getParameterCount());

+ VASSERT_EQ("2.2", "param1", PARAM_NAME(p2, 0));

+ VASSERT_EQ("2.3", "charset", PARAM_CHARSET(p2, 0));

+ VASSERT_EQ("2.4", "value1value2", PARAM_BUFFER(p2, 0));

+

+ // Characters prefixed with '%' in a simple (not extended) section

+ // should not be decoded

+ parameterizedHeaderField p3;

+ p3.parse("X; param1=val%20ue1");

+

+ VASSERT_EQ("3.1", 1, p3.getParameterCount());

+ VASSERT_EQ("3.2", "param1", PARAM_NAME(p3, 0));

+ VASSERT_EQ("3.3", "val%20ue1", PARAM_VALUE(p3, 0));

+

+ // Multiple sections + charset specified and encoding

+ parameterizedHeaderField p4;

+ p4.parse(

+ "X; param1*0*=charset'language'value1a%20;"

+ " param1*1*=value1b%20;"

+ " param1*2=value1c"

+ );

+

+ VASSERT_EQ("4.1", 1, p4.getParameterCount());

+ VASSERT_EQ("4.2", "param1", PARAM_NAME(p4, 0));

+ VASSERT_EQ("4.3", "charset", PARAM_CHARSET(p4, 0));

+ VASSERT_EQ("4.4", "value1a value1b value1c", PARAM_BUFFER(p4, 0));

+

+ // No charset specified: defaults to US-ASCII

+ parameterizedHeaderField p5;

+ p5.parse("X; param1*='language'value1");

+

+ VASSERT_EQ("5.1", 1, p5.getParameterCount());

+ VASSERT_EQ("5.2", "param1", PARAM_NAME(p5, 0));

+ VASSERT_EQ("5.3", "us-ascii", PARAM_CHARSET(p5, 0));

+ VASSERT_EQ("5.4", "value1", PARAM_BUFFER(p5, 0));

+

+ // Language specification

+ parameterizedHeaderField p6;

+ p6.parse("X; param1*=us-ascii'en-us'This%20is%20%2A%2A%2Afun%2A%2A%2A");

+

+ VASSERT_EQ("6.1", 1, p6.getParameterCount());

+ VASSERT_EQ("6.2", "param1", PARAM_NAME(p6, 0));

+ VASSERT_EQ("6.3", "us-ascii", PARAM_CHARSET(p6, 0));

+ VASSERT_EQ("6.4", "en-us", PARAM_LANG(p6, 0));

+ VASSERT_EQ("6.5", "This is ***fun***", PARAM_BUFFER(p6, 0));

+ }

+

+ void testGenerate() {

+

+ // Simple parameter/value

+ parameterizedHeaderField p1;

+ 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::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::make_shared <vmime::parameter>("param1", "va\\lue\"1"));

+

+ VASSERT_EQ("2b", "F: X; param1=\"va\\\\lue\\\"1\"", p2b.generate());

+ }

+

+ void testGetGeneratedSize() {

+

+ vmime::generationContext ctx(vmime::generationContext::getDefaultContext());

+

+ vmime::parameter p1("param1", "value1");

+ VASSERT("1", p1.getGeneratedSize(ctx) >= generateParameter(p1, ctx).length());

+

+ vmime::parameter p2a("param1", "value1a;value1b");

+ VASSERT("2&", p2a.getGeneratedSize(ctx) >= generateParameter(p2a, ctx).length());

+

+ vmime::parameter p2b("param1", "va\\lue\"1");

+ VASSERT("1", p2b.getGeneratedSize(ctx) >= generateParameter(p2b, ctx).length());

+ }

+

+ void testGenerateRFC2231() {

+

+ // Extended parameter with charset specifier

+ parameterizedHeaderField p1;

+ p1.appendParameter(

+ vmime::make_shared <vmime::parameter>(

+ "param1",

+ vmime::word("value 1\xe9", vmime::charset("charset"))

+ )

+ );

+

+ VASSERT_EQ(

+ "1.no-encoding",

+ "F: X; param1=\"value 1\"",

+ p1.generate(vmime::generationContext::PARAMETER_VALUE_NO_ENCODING)

+ );

+

+ VASSERT_EQ(

+ "1.rfc2047",

+ "F: X; param1=\"=?charset?Q?value_1=E9?=\"",

+ p1.generate(vmime::generationContext::PARAMETER_VALUE_RFC2047_ONLY)

+ );

+

+ VASSERT_EQ(

+ "1.rfc2231",

+ "F: X; param1*=charset''value%201%E9",

+ p1.generate(vmime::generationContext::PARAMETER_VALUE_RFC2231_ONLY)

+ );

+

+ VASSERT_EQ(

+ "1.both",

+ "F: X; param1=\"=?charset?Q?value_1=E9?=\";param1*=charset''value%201%E9",

+ p1.generate(vmime::generationContext::PARAMETER_VALUE_RFC2231_AND_RFC2047)

+ );

+

+ // Value that spans on multiple lines

+ parameterizedHeaderField p2;

+ p2.appendParameter(

+ vmime::make_shared <vmime::parameter>(

+ "param1",

+ vmime::word(

+ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",

+ vmime::charset("charset")

+ )

+ )

+ );

+

+ VASSERT_EQ(

+ "2.no-encoding",

+ "F: X; \r\n "

+ "param1=abcdefghijkl",

+ p2.generate(vmime::generationContext::PARAMETER_VALUE_NO_ENCODING, 25) // max line length = 25

+ );

+

+ VASSERT_EQ(

+ "2.rfc2047",

+ "F: X; \r\n "

+ "param1=abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",

+ p2.generate(vmime::generationContext::PARAMETER_VALUE_RFC2047_ONLY, 25) // max line length = 25

+ );

+

+ VASSERT_EQ(

+ "2.rfc2231",

+ "F: X; \r\n "

+ "param1*0*=charset''abc;\r\n "

+ "param1*1*=defghijkl;\r\n "

+ "param1*2*=mnopqrstu;\r\n "

+ "param1*3*=vwxyzABCD;\r\n "

+ "param1*4*=EFGHIJKLM;\r\n "

+ "param1*5*=NOPQRSTUV;\r\n "

+ "param1*6*=WXYZ",

+ p2.generate(vmime::generationContext::PARAMETER_VALUE_RFC2231_ONLY, 25) // max line length = 25

+ );

+

+ VASSERT_EQ(

+ "2.both",

+ "F: X; \r\n "

+ "param1=abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;\r\n "

+ "param1*0*=charset''abc;\r\n "

+ "param1*1*=defghijkl;\r\n "

+ "param1*2*=mnopqrstu;\r\n "

+ "param1*3*=vwxyzABCD;\r\n "

+ "param1*4*=EFGHIJKLM;\r\n "

+ "param1*5*=NOPQRSTUV;\r\n "

+ "param1*6*=WXYZ",

+ p2.generate(vmime::generationContext::PARAMETER_VALUE_RFC2231_AND_RFC2047, 25) // max line length = 25

+ );

+

+ // Non-ASCII parameter value

+ parameterizedHeaderField p3;

+ p3.appendParameter(

+ vmime::make_shared <vmime::parameter>(

+ "param1",

+ vmime::word(

+ "δσσσσσσσσσσσσσσσσσσσσδσδα δσαδσδσαδσαδασδασ δσαδασδσα δσαδασδσα δασδασδασ δασαχφδδσα 2008.doc",

+ vmime::charset("utf-8")

+ )

+ )

+ );

+

+ VASSERT_EQ(

+ "3.no-encoding",

+ "F: X; \r\n "

+ "param1=\" 2008.doc\"",

+ p3.generate(vmime::generationContext::PARAMETER_VALUE_NO_ENCODING, 80) // max line length = 80

+ );

+

+ VASSERT_EQ(

+ "3.7bit-only",

+ "F: X; \r\n "

+ "param1=\"=?utf-8?B?zrTPg8+Dz4PPg8+Dz4PPg8+Dz4PPg8+Dz4PPg8+Dz4PPg8+Dz4PPg8+DzrTPg860?=\r\n "

+ "=?utf-8?B?zrEgzrTPg86xzrTPg860z4POsc60z4POsc60zrHPg860zrHPgyDOtM+DzrHOtM6x?=\r\n "

+ "=?utf-8?B?z4POtM+DzrEgzrTPg86xzrTOsc+DzrTPg86xIM60zrHPg860zrHPg860zrHPgyDOtA==?=\r\n "

+ "=?utf-8?B?zrHPg86xz4fPhs60zrTPg86xIDIwMDguZG9j?=\"",

+ p3.generate(vmime::generationContext::PARAMETER_VALUE_RFC2047_ONLY, 80) // max line length = 80

+ );

+

+ VASSERT_EQ(

+ "3.both",

+ "F: X; \r\n "

+ "param1=\"=?utf-8?B?zrTPg8+Dz4PPg8+Dz4PPg8+Dz4PPg8+Dz4PPg8+Dz4PPg8+Dz4PPg8+DzrTPg860?=\r\n "

+ "=?utf-8?B?zrEgzrTPg86xzrTPg860z4POsc60z4POsc60zrHPg860zrHPgyDOtM+DzrHOtM6x?=\r\n "

+ "=?utf-8?B?z4POtM+DzrEgzrTPg86xzrTOsc+DzrTPg86xIM60zrHPg860zrHPg860zrHPgyDOtA==?=\r\n "

+ "=?utf-8?B?zrHPg86xz4fPhs60zrTPg86xIDIwMDguZG9j?=\";\r\n "

+ "param1*0*=utf-8''%CE%B4%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83;\r\n "

+ "param1*1*=%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83;\r\n "

+ "param1*2*=%CE%B4%CF%83%CE%B4%CE%B1%20%CE%B4%CF%83%CE%B1%CE%B4%CF%83%CE%B4%CF;\r\n "

+ "param1*3*=%83%CE%B1%CE%B4%CF%83%CE%B1%CE%B4%CE%B1%CF%83%CE%B4%CE%B1%CF%83%20;\r\n "

+ "param1*4*=%CE%B4%CF%83%CE%B1%CE%B4%CE%B1%CF%83%CE%B4%CF%83%CE%B1%20%CE%B4%CF;\r\n "

+ "param1*5*=%83%CE%B1%CE%B4%CE%B1%CF%83%CE%B4%CF%83%CE%B1%20%CE%B4%CE%B1%CF%83;\r\n "

+ "param1*6*=%CE%B4%CE%B1%CF%83%CE%B4%CE%B1%CF%83%20%CE%B4%CE%B1%CF%83%CE%B1%CF;\r\n "

+ "param1*7*=%87%CF%86%CE%B4%CE%B4%CF%83%CE%B1%202008.doc",

+ p3.generate(vmime::generationContext::PARAMETER_VALUE_RFC2231_AND_RFC2047, 80) // max line length = 80

+ );

+

+ VASSERT_EQ(

+ "3.either",

+ "F: X; param1*0*=utf-8''%CE%B4%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83;\r\n "

+ "param1*1*=%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83%CF%83;\r\n "

+ "param1*2*=%CE%B4%CF%83%CE%B4%CE%B1%20%CE%B4%CF%83%CE%B1%CE%B4%CF%83%CE%B4%CF;\r\n "

+ "param1*3*=%83%CE%B1%CE%B4%CF%83%CE%B1%CE%B4%CE%B1%CF%83%CE%B4%CE%B1%CF%83%20;\r\n "

+ "param1*4*=%CE%B4%CF%83%CE%B1%CE%B4%CE%B1%CF%83%CE%B4%CF%83%CE%B1%20%CE%B4%CF;\r\n "

+ "param1*5*=%83%CE%B1%CE%B4%CE%B1%CF%83%CE%B4%CF%83%CE%B1%20%CE%B4%CE%B1%CF%83;\r\n "

+ "param1*6*=%CE%B4%CE%B1%CF%83%CE%B4%CE%B1%CF%83%20%CE%B4%CE%B1%CF%83%CE%B1%CF;\r\n "

+ "param1*7*=%87%CF%86%CE%B4%CE%B4%CF%83%CE%B1%202008.doc",

+ p3.generate(vmime::generationContext::PARAMETER_VALUE_RFC2231_ONLY, 80) // max line length = 80

+ );

+

+ // No encoding needed

+ parameterizedHeaderField p4;

+ p4.appendParameter(

+ vmime::make_shared <vmime::parameter>(

+ "param1",

+ vmime::word("va lue", vmime::charset("charset"))

+ )

+ );

+

+ VASSERT_EQ(

+ "4.no-encoding",

+ "F: X; param1=\"va lue\"",

+ p4.generate(vmime::generationContext::PARAMETER_VALUE_NO_ENCODING)

+ );

+

+ VASSERT_EQ(

+ "4.rfc2047",

+ "F: X; param1=\"va lue\"",

+ p4.generate(vmime::generationContext::PARAMETER_VALUE_RFC2047_ONLY)

+ );

+

+ VASSERT_EQ(

+ "4.rfc2231",

+ "F: X; param1=\"va lue\"",

+ p4.generate(vmime::generationContext::PARAMETER_VALUE_RFC2231_ONLY)

+ );

+

+ VASSERT_EQ(

+ "4.both",

+ "F: X; param1=\"va lue\"",

+ p4.generate(vmime::generationContext::PARAMETER_VALUE_RFC2231_AND_RFC2047)

+ );

+

+ // Language specification

+ parameterizedHeaderField p5;

+ p5.appendParameter(

+ vmime::make_shared <vmime::parameter>("param1",

+ vmime::word("This is ***fun***", vmime::charset("us-ascii"), "en-us"))

+ );

+

+ VASSERT_EQ(

+ "5.no-encoding",

+ "F: X; param1=\"This is ***fun***\"",

+ p5.generate(vmime::generationContext::PARAMETER_VALUE_NO_ENCODING)

+ );

+

+ VASSERT_EQ(

+ "5.rfc2047",

+ "F: X; param1=\"=?us-ascii*en-us?Q?This_is_***fun***?=\"",

+ p5.generate(vmime::generationContext::PARAMETER_VALUE_RFC2047_ONLY)

+ );

+

+ VASSERT_EQ(

+ "5.rfc2231",

+ "F: X; param1*=us-ascii''This%20is%20***fun***",

+ p5.generate(vmime::generationContext::PARAMETER_VALUE_RFC2231_ONLY)

+ );

+

+ VASSERT_EQ(

+ "5.both",

+ "F: X; "

+ "param1=\"=?us-ascii*en-us?Q?This_is_***fun***?=\";\r\n "

+ "param1*=us-ascii''This%20is%20***fun***",

+ p5.generate(vmime::generationContext::PARAMETER_VALUE_RFC2231_AND_RFC2047));

+ }

+

+ void testGetGeneratedSizeRFC2231() {

+

+ vmime::generationContext ctx(vmime::generationContext::getDefaultContext());

+

+ // Extended parameter with charset specifier

+ vmime::parameter p1(

+ "param1",

+ vmime::word("value 1\xe9", vmime::charset("charset"))

+ );

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_NO_ENCODING);

+ VASSERT("1.no-encoding", p1.getGeneratedSize(ctx) >= generateParameter(p1, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2047_ONLY);

+ VASSERT("1.rfc2047", p1.getGeneratedSize(ctx) >= generateParameter(p1, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2231_ONLY);

+ VASSERT("1.rfc2231", p1.getGeneratedSize(ctx) >= generateParameter(p1, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2231_AND_RFC2047);

+ VASSERT("1.both", p1.getGeneratedSize(ctx) >= generateParameter(p1, ctx).length());

+

+ // Value that spans on multiple lines

+ vmime::parameter p2(

+ "param1",

+ vmime::word(

+ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",

+ vmime::charset("charset")

+ )

+ );

+

+ ctx.setMaxLineLength(25);

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_NO_ENCODING);

+ VASSERT("2.no-encoding", p2.getGeneratedSize(ctx) >= generateParameter(p2, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2047_ONLY);

+ VASSERT("2.rfc2047", p2.getGeneratedSize(ctx) >= generateParameter(p2, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2231_ONLY);

+ VASSERT("2.rfc2231", p2.getGeneratedSize(ctx) >= generateParameter(p2, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2231_AND_RFC2047);

+ VASSERT("2.both", p2.getGeneratedSize(ctx) >= generateParameter(p2, ctx).length());

+

+ // Non-ASCII parameter value

+ vmime::parameter p3(

+ "param1",

+ vmime::word(

+ "δσσσσσσσσσσσσσσσσσσσσδσδα δσαδσδσαδσαδασδασ δσαδασδσα δσαδασδσα δασδασδασ δασαχφδδσα 2008.doc",

+ vmime::charset("utf-8")

+ )

+ );

+

+ ctx.setMaxLineLength(vmime::generationContext::getDefaultContext().getMaxLineLength());

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_NO_ENCODING);

+ VASSERT("3.no-encoding", p3.getGeneratedSize(ctx) >= generateParameter(p3, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2047_ONLY);

+ VASSERT("3.rfc2047", p3.getGeneratedSize(ctx) >= generateParameter(p3, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2231_ONLY);

+ VASSERT("3.rfc2231", p3.getGeneratedSize(ctx) >= generateParameter(p3, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2231_AND_RFC2047);

+ VASSERT("3.both", p3.getGeneratedSize(ctx) >= generateParameter(p3, ctx).length());

+

+ // No encoding needed

+ vmime::parameter p4(

+ "param1",

+ vmime::word("va lue", vmime::charset("charset"))

+ );

+

+ ctx.setMaxLineLength(vmime::generationContext::getDefaultContext().getMaxLineLength());

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_NO_ENCODING);

+ VASSERT("4.no-encoding", p4.getGeneratedSize(ctx) >= generateParameter(p4, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2047_ONLY);

+ VASSERT("4.rfc2047", p4.getGeneratedSize(ctx) >= generateParameter(p4, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2231_ONLY);

+ VASSERT("4.rfc2231", p4.getGeneratedSize(ctx) >= generateParameter(p4, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2231_AND_RFC2047);

+ VASSERT("4.both", p4.getGeneratedSize(ctx) >= generateParameter(p4, ctx).length());

+

+ // Language specification

+ vmime::parameter p5(

+ "param1",

+ vmime::word("This is ***fun***", vmime::charset("us-ascii"), "en-us")

+ );

+

+ ctx.setMaxLineLength(vmime::generationContext::getDefaultContext().getMaxLineLength());

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_NO_ENCODING);

+ VASSERT("5.no-encoding", p5.getGeneratedSize(ctx) >= generateParameter(p5, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2047_ONLY);

+ VASSERT("5.rfc2047", p5.getGeneratedSize(ctx) >= generateParameter(p5, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2231_ONLY);

+ VASSERT("5.rfc2231", p5.getGeneratedSize(ctx) >= generateParameter(p5, ctx).length());

+

+ ctx.setEncodedParameterValueMode(vmime::generationContext::PARAMETER_VALUE_RFC2231_AND_RFC2047);

+ VASSERT("5.both", p5.getGeneratedSize(ctx) >= generateParameter(p5, ctx).length());

+ }

+

+ void testNonStandardEncodedParam() {

+

+ // This syntax is non-standard (expressly prohibited

+ // by RFC-2047), but is used by Mozilla:

+ //

+ // Content-Type: image/png;

+ // name="=?us-ascii?Q?Logo_VMime=2Epng?="

+

+ parameterizedHeaderField p1;

+ p1.parse("image/png; name=\"=?us-ascii?Q?Logo_VMime=2Epng?=\"");

+

+ VASSERT_EQ("1.1", 1, p1.getParameterCount());

+ VASSERT_EQ("1.2", "name", PARAM_NAME(p1, 0));

+ VASSERT_EQ("1.3", "Logo VMime.png", PARAM_VALUE(p1, 0));

+

+ parameterizedHeaderField p2;

+ p2.parse("image/png; name=\"Logo =?us-ascii?Q?VMime=2Epng?=\"");

+

+ VASSERT_EQ("2.1", 1, p2.getParameterCount());

+ VASSERT_EQ("2.2", "name", PARAM_NAME(p2, 0));

+ VASSERT_EQ("2.3", "Logo VMime.png", PARAM_VALUE(p2, 0));

+ }

+

+ // Parse parameters with non-significant whitespaces

+ void testParseNonSignificantWS() {

+

+ parameterizedHeaderField p1;

+ p1.parse(" \t X \r\n");

+

+ VASSERT_EQ("1.1", "X", FIELD_VALUE(p1));

+

+ parameterizedHeaderField p2;

+ p2.parse(" X ; param1 = value1 \r\n");

+

+ VASSERT_EQ("2.1", 1, p2.getParameterCount());

+ VASSERT_EQ("2.2", "X", FIELD_VALUE(p2));

+ VASSERT_EQ("2.3", "param1", PARAM_NAME(p2, 0));

+ VASSERT_EQ("2.4", "value1", PARAM_VALUE(p2, 0));

+ }

+

+ // Encode "tspecials"

+ void testEncodeTSpecials() {

+

+ 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::make_shared <vmime::parameter>(

+ "filename",

+ vmime::word("my_file_name_\xc3\xb6\xc3\xa4\xc3\xbc_(1).txt", "UTF-8")

+ )->generate()

+ );

+ }

+

+ void testWhitespaceBreaksTheValue() {

+

+ parameterizedHeaderField p;

+ p.parse("xxx yyy; param1=value1 \r\n");

+

+ VASSERT_EQ("count", 1, p.getParameterCount());

+ VASSERT_EQ("value", "xxx", FIELD_VALUE(p));

+ VASSERT_EQ("param1.name", "param1", PARAM_NAME(p, 0));

+ VASSERT_EQ("param1.value", "value1", PARAM_VALUE(p, 0));

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(pathTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testParse)

+ VMIME_TEST(testParse2)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST_LIST_END

+

+

+ void testParse() {

+

+ vmime::path p1;

+ p1.parse("<>");

+

+ VASSERT_EQ("1.1", "", p1.getLocalPart());

+ VASSERT_EQ("1.2", "", p1.getDomain());

+

+ vmime::path p2;

+ p2.parse("<domain>");

+

+ VASSERT_EQ("2.1", "", p2.getLocalPart());

+ VASSERT_EQ("2.2", "domain", p2.getDomain());

+

+ vmime::path p3;

+ p3.parse("<local@domain>");

+

+ VASSERT_EQ("3.1", "local", p3.getLocalPart());

+ VASSERT_EQ("3.2", "domain", p3.getDomain());

+ }

+

+ void testParse2() {

+

+ // Test some invalid paths (no '<>')

+ vmime::path p1;

+ p1.parse("");

+

+ VASSERT_EQ("1.1", "", p1.getLocalPart());

+ VASSERT_EQ("1.2", "", p1.getDomain());

+

+ vmime::path p2;

+ p2.parse("domain");

+

+ VASSERT_EQ("2.1", "", p2.getLocalPart());

+ VASSERT_EQ("2.2", "domain", p2.getDomain());

+

+ vmime::path p3;

+ p3.parse("local@domain");

+

+ VASSERT_EQ("3.1", "local", p3.getLocalPart());

+ VASSERT_EQ("3.2", "domain", p3.getDomain());

+ }

+

+ void testGenerate() {

+

+ vmime::path p1;

+

+ VASSERT_EQ("1", "<>", p1.generate());

+

+ vmime::path p2;

+ p2.setLocalPart("local");

+

+ VASSERT_EQ("2", "<local@>", p2.generate());

+

+ vmime::path p3;

+ p3.setDomain("domain");

+

+ VASSERT_EQ("3", "<@domain>", p3.generate());

+

+ vmime::path p4;

+ p4.setLocalPart("local");

+ p4.setDomain("domain");

+

+ VASSERT_EQ("4", "<local@domain>", p4.generate());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+#include "vmime/utility/outputStreamAdapter.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(streamContentHandlerTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testIsEmpty)

+ VMIME_TEST(testGetLength)

+ VMIME_TEST(testIsEncoded)

+ VMIME_TEST(testGetLength_Encoded)

+ VMIME_TEST(testExtract)

+ VMIME_TEST(testExtract_Encoded)

+ VMIME_TEST(testExtractRaw_Encoded)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST(testGenerate_Encoded)

+ VMIME_TEST_LIST_END

+

+

+ void testIsEmpty() {

+

+ vmime::streamContentHandler cth;

+

+ VASSERT_TRUE("empty", cth.isEmpty());

+ }

+

+ void testGetLength() {

+

+ vmime::string data("Test Data");

+ vmime::shared_ptr <vmime::utility::inputStream> stream =

+ vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);

+

+ vmime::streamContentHandler cth(stream, data.length());

+

+ VASSERT_FALSE("empty", cth.isEmpty());

+ VASSERT_EQ("length", 9, cth.getLength());

+ }

+

+ void testIsEncoded() {

+

+ vmime::string data("Test Data");

+ vmime::shared_ptr <vmime::utility::inputStream> stream =

+ vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);

+

+ vmime::streamContentHandler cth(stream, data.length());

+

+ VASSERT_FALSE("encoded", cth.isEncoded());

+ VASSERT_EQ("encoding", vmime::contentHandler::NO_ENCODING, cth.getEncoding());

+

+

+ vmime::string data2("Zm9vEjRWYmFy=");

+ vmime::shared_ptr <vmime::utility::inputStream> stream2 =

+ vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data2);

+

+ vmime::streamContentHandler cth2(stream2, data2.length(), vmime::encoding("base64"));

+

+ VASSERT_TRUE("encoded", cth2.isEncoded());

+ VASSERT_EQ("encoding", "base64", cth2.getEncoding().generate());

+ }

+

+ void testGetLength_Encoded() {

+

+ vmime::string data("foo=12=34=56bar");

+ vmime::shared_ptr <vmime::utility::inputStream> stream =

+ vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);

+

+ vmime::streamContentHandler cth(stream, data.length(), vmime::encoding("quoted-printable"));

+

+ // Reported length should be the length of encoded data

+ VASSERT_EQ("length", 15, cth.getLength());

+ }

+

+ void testExtract() {

+

+ vmime::string data("Test Data");

+ vmime::shared_ptr <vmime::utility::inputStream> stream =

+ vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);

+

+ vmime::streamContentHandler cth(stream, data.length());

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.extract(osa);

+

+ VASSERT_EQ("extract", "Test Data", oss.str());

+ }

+

+ void testExtract_Encoded() {

+

+ vmime::string data(

+ "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODk="

+ );

+

+ vmime::shared_ptr <vmime::utility::inputStream> stream =

+ vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);

+

+ vmime::streamContentHandler cth(stream, data.length(), vmime::encoding("base64"));

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.extract(osa);

+

+ // Data should be decoded from B64

+ VASSERT_EQ(

+ "extract",

+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",

+ oss.str()

+ );

+ }

+

+ void testExtractRaw_Encoded()

+ {

+ vmime::string data(

+ "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODk="

+ );

+ vmime::shared_ptr <vmime::utility::inputStream> stream =

+ vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);

+

+ vmime::streamContentHandler cth(stream, data.length(), vmime::encoding("base64"));

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.extractRaw(osa);

+

+ // Data should not be decoded

+ VASSERT_EQ(

+ "extractRaw",

+ "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODk=",

+ oss.str()

+ );

+ }

+

+ void testGenerate() {

+

+ vmime::string data("foo\x12\x34\x56 bar");

+ vmime::shared_ptr <vmime::utility::inputStream> stream =

+ vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);

+

+ vmime::streamContentHandler cth(stream, data.length());

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.generate(osa, vmime::encoding("base64"));

+

+ // Data should be encoded to B64

+ VASSERT_EQ("generate", "Zm9vEjRWIGJhcg==", oss.str());

+ }

+

+ void testGenerate_Encoded() {

+

+ vmime::string data("foo=12=34=56bar");

+ vmime::shared_ptr <vmime::utility::inputStream> stream =

+ vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);

+

+ vmime::streamContentHandler cth(stream, data.length(), vmime::encoding("quoted-printable"));

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.generate(osa, vmime::encoding("base64"));

+

+ // Data should be reencoded from QP to B64

+ VASSERT_EQ("generate", "Zm9vEjRWYmFy", oss.str());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+#include "vmime/utility/outputStreamAdapter.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(stringContentHandlerTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testIsEmpty)

+ VMIME_TEST(testGetLength)

+ VMIME_TEST(testIsEncoded)

+ VMIME_TEST(testGetLength_Encoded)

+ VMIME_TEST(testExtract)

+ VMIME_TEST(testExtract_Encoded)

+ VMIME_TEST(testExtractRaw_Encoded)

+ VMIME_TEST(testGenerate)

+ VMIME_TEST(testGenerate_Encoded)

+ VMIME_TEST_LIST_END

+

+

+ void testIsEmpty() {

+

+ vmime::stringContentHandler cth;

+

+ VASSERT_TRUE("empty", cth.isEmpty());

+ }

+

+ void testGetLength() {

+

+ vmime::stringContentHandler cth("Test Data");

+

+ VASSERT_FALSE("empty", cth.isEmpty());

+ VASSERT_EQ("length", 9, cth.getLength());

+ }

+

+ void testIsEncoded() {

+

+ vmime::stringContentHandler cth("Test Data");

+

+ VASSERT_FALSE("encoded", cth.isEncoded());

+ VASSERT_EQ("encoding", vmime::contentHandler::NO_ENCODING, cth.getEncoding());

+

+

+ vmime::stringContentHandler cth2("Zm9vEjRWYmFy=", vmime::encoding("base64"));

+

+ VASSERT_TRUE("encoded", cth2.isEncoded());

+ VASSERT_EQ("encoding", "base64", cth2.getEncoding().generate());

+ }

+

+ void testGetLength_Encoded() {

+

+ vmime::stringContentHandler cth(

+ "foo=12=34=56bar",

+ vmime::encoding("quoted-printable")

+ );

+

+ // Reported length should be the length of encoded data

+ VASSERT_EQ("length", 15, cth.getLength());

+ }

+

+ void testExtract() {

+

+ vmime::stringContentHandler cth("Test Data");

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.extract(osa);

+

+ VASSERT_EQ("extract", "Test Data", oss.str());

+ }

+

+ void testExtract_Encoded() {

+

+ vmime::stringContentHandler cth(

+ "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODk=",

+ vmime::encoding("base64")

+ );

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.extract(osa);

+

+ // Data should be decoded from B64

+ VASSERT_EQ(

+ "extract",

+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",

+ oss.str()

+ );

+ }

+

+ void testExtractRaw_Encoded() {

+

+ vmime::stringContentHandler cth(

+ "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODk=",

+ vmime::encoding("base64")

+ );

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.extractRaw(osa);

+

+ // Data should not be decoded

+ VASSERT_EQ(

+ "extractRaw",

+ "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODk=",

+ oss.str()

+ );

+ }

+

+ void testGenerate() {

+

+ vmime::stringContentHandler cth("foo\x12\x34\x56 bar");

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.generate(osa, vmime::encoding("base64"));

+

+ // Data should be encoded to B64

+ VASSERT_EQ("generate", "Zm9vEjRWIGJhcg==", oss.str());

+ }

+

+ void testGenerate_Encoded() {

+

+ vmime::stringContentHandler cth(

+ "foo=12=34=56bar",

+ vmime::encoding("quoted-printable")

+ );

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter osa(oss);

+

+ cth.generate(osa, vmime::encoding("base64"));

+

+ // Data should be reencoded from QP to B64

+ VASSERT_EQ("generate", "Zm9vEjRWYmFy", oss.str());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+#include <locale>

+#include <clocale>

+

+

+VMIME_TEST_SUITE_BEGIN(textTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testConstructors)

+ VMIME_TEST(testCopy)

+ VMIME_TEST(testNewFromString)

+ VMIME_TEST(testDisplayForm)

+ VMIME_TEST(testParse)

+ VMIME_TEST(testGenerate)

+

+ VMIME_TEST(testWordConstructors)

+ VMIME_TEST(testWordParse)

+ VMIME_TEST(testWordGenerate)

+ VMIME_TEST(testWordGenerateSpace)

+ VMIME_TEST(testWordGenerateSpace2)

+ VMIME_TEST(testWordGenerateMultiBytes)

+ VMIME_TEST(testWordGenerateQuote)

+ VMIME_TEST(testWordGenerateSpecialCharsets)

+ VMIME_TEST(testWordGenerateSpecials)

+

+ VMIME_TEST(testWhitespace)

+ VMIME_TEST(testWhitespaceMBox)

+

+ VMIME_TEST(testFoldingAscii)

+ VMIME_TEST(testForcedNonEncoding)

+

+ VMIME_TEST(testBugFix20110511)

+

+ VMIME_TEST(testInternationalizedEmail_specialChars)

+ VMIME_TEST(testInternationalizedEmail_UTF8)

+ VMIME_TEST(testInternationalizedEmail_nonUTF8)

+ VMIME_TEST(testInternationalizedEmail_folding)

+ VMIME_TEST(testInternationalizedEmail_whitespace)

+

+ VMIME_TEST(testWronglyPaddedB64Words)

+ VMIME_TEST(testFixBrokenWords)

+ VMIME_TEST(testUnknownCharset)

+ VMIME_TEST_LIST_END

+

+

+ static const vmime::string getDisplayText(const vmime::text& t) {

+

+ return t.getWholeBuffer();

+ }

+

+ static const vmime::string cleanGeneratedWords(const std::string& str) {

+

+ std::istringstream iss(str);

+

+ std::string res;

+ std::string x;

+

+ while (std::getline(iss, x)) {

+ res += vmime::utility::stringUtils::trim(x);

+ }

+

+ return res;

+ }

+

+

+ void setUp() {

+

+ // Set the global C and C++ locale to the user-configured locale.

+ // The locale should use UTF-8 encoding for these tests to run successfully.

+ try {

+ std::locale::global(std::locale(""));

+ } catch (std::exception &) {

+ std::setlocale(LC_ALL, "");

+ }

+ }

+

+ void tearDown() {

+

+ // Restore default locale

+ std::locale::global(std::locale("C"));

+ }

+

+

+ void testConstructors() {

+

+ vmime::text t1;

+

+ VASSERT_EQ("1.1", 0, t1.getWordCount());

+

+ vmime::text t2("Test\xa9\xc3");

+

+ VASSERT_EQ("2.1", 1, t2.getWordCount());

+ VASSERT_EQ("2.2", "Test\xa9\xc3", t2.getWordAt(0)->getBuffer());

+ VASSERT_EQ("2.3", vmime::charset::getLocalCharset(), t2.getWordAt(0)->getCharset());

+

+ vmime::text t3("Test\xa9\xc3", vmime::charset(vmime::charsets::ISO8859_13));

+

+ VASSERT_EQ("3.1", 1, t3.getWordCount());

+ VASSERT_EQ("3.2", "Test\xa9\xc3", t3.getWordAt(0)->getBuffer());

+ VASSERT_EQ("3.3", vmime::charset(vmime::charsets::ISO8859_13), t3.getWordAt(0)->getCharset());

+

+ vmime::word w1("Test", vmime::charset(vmime::charsets::UTF_8));

+ vmime::text t4(w1);

+

+ VASSERT_EQ("4.1", 1, t4.getWordCount());

+ VASSERT_EQ("4.2", w1.getBuffer(), t4.getWordAt(0)->getBuffer());

+ VASSERT_EQ("4.3", w1.getCharset(), t4.getWordAt(0)->getCharset());

+

+ vmime::word w2("Other", vmime::charset(vmime::charsets::US_ASCII));

+ t4.appendWord(vmime::make_shared <vmime::word>(w2));

+

+ vmime::text t5(t4);

+

+ VASSERT_EQ("5.1", 2, t5.getWordCount());

+ VASSERT_EQ("5.2", w1.getBuffer(), t5.getWordAt(0)->getBuffer());

+ VASSERT_EQ("5.3", w1.getCharset(), t5.getWordAt(0)->getCharset());

+ VASSERT_EQ("5.4", w2.getBuffer(), t5.getWordAt(1)->getBuffer());

+ VASSERT_EQ("5.5", w2.getCharset(), t5.getWordAt(1)->getCharset());

+ }

+

+ void testCopy() {

+

+ vmime::text t1("Test: \xa9\xc3");

+

+ VASSERT("operator==", t1 == t1);

+ VASSERT("clone", *vmime::clone(t1) == t1);

+

+ vmime::text t2;

+ t2.copyFrom(t1);

+

+ VASSERT("copyFrom", t1 == t2);

+ }

+

+ void testNewFromString() {

+

+ vmime::string s1 = "only ASCII characters";

+ vmime::charset c1("test");

+ vmime::text t1;

+

+ t1.createFromString(s1, c1);

+

+ VASSERT_EQ("1.1", 1, t1.getWordCount());

+ VASSERT_EQ("1.2", s1, t1.getWordAt(0)->getBuffer());

+ VASSERT_EQ("1.3", vmime::charset(vmime::charsets::US_ASCII), t1.getWordAt(0)->getCharset());

+

+ vmime::string s2_1 = "some ASCII characters and special chars: ";

+ vmime::string s2_2 = "\xf1\xf2\xf3\xf4 ";

+ vmime::string s2_3 = "and then more ASCII chars.";

+ vmime::string s2 = s2_1 + s2_2 + s2_3;

+ vmime::charset c2("test");

+ vmime::text t2;

+

+ t2.createFromString(s2, c2);

+

+ VASSERT_EQ("2.1", 3, t2.getWordCount());

+ VASSERT_EQ("2.2", "some ASCII characters and special chars: ", t2.getWordAt(0)->getBuffer());

+ VASSERT_EQ("2.3", vmime::charset(vmime::charsets::US_ASCII), t2.getWordAt(0)->getCharset());

+ VASSERT_EQ("2.4", "\xf1\xf2\xf3\xf4", t2.getWordAt(1)->getBuffer());

+ VASSERT_EQ("2.5", c2, t2.getWordAt(1)->getCharset());

+ VASSERT_EQ("2.6", "and then more ASCII chars.", t2.getWordAt(2)->getBuffer());

+ VASSERT_EQ("2.7", vmime::charset(vmime::charsets::US_ASCII), t2.getWordAt(2)->getCharset());

+ }

+

+ static const vmime::string parseText(const vmime::string& buffer) {

+

+ vmime::text t;

+ t.parse(buffer);

+

+ std::ostringstream oss;

+ oss << t;

+

+ return oss.str();

+ }

+

+ void testParse() {

+

+ // From RFC-2047

+ VASSERT_EQ(

+ "1",

+ "[text: [[word: charset=US-ASCII, buffer=Keith Moore]]]",

+ parseText("=?US-ASCII?Q?Keith_Moore?=")

+ );

+

+ VASSERT_EQ(

+ "2",

+ "[text: [[word: charset=ISO-8859-1, buffer=Keld J\xf8rn Simonsen]]]",

+ parseText("=?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?=")

+ );

+

+ VASSERT_EQ(

+ "3",

+ "[text: [[word: charset=ISO-8859-1, buffer=Andr\xe9]," \

+ "[word: charset=us-ascii, buffer= Pirard]]]",

+ parseText("=?ISO-8859-1?Q?Andr=E9?= Pirard")

+ );

+

+ VASSERT_EQ(

+ "4",

+ "[text: [[word: charset=ISO-8859-1, buffer=If you can read this yo]," \

+ "[word: charset=ISO-8859-2, buffer=u understand the example.]]]",

+ parseText(

+ "=?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=\r\n " \

+ "=?ISO-8859-2?B?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?="

+ )

+ );

+

+ // Bugfix: in "=?charset?q?=XX=YY?=", the "?=" finish

+ // sequence was not correctly found (should be the one

+ // after '=YY' and not the one after '?q').

+ VASSERT_EQ(

+ "5",

+ "[text: [[word: charset=abc, buffer=\xe9\xe9]]]",

+ parseText("=?abc?q?=E9=E9?=")

+ );

+

+ // Question marks (?) in the middle of the string

+ VASSERT_EQ(

+ "6",

+ "[text: [[word: charset=iso-8859-1, buffer=Know wh\xe4t? It works!]]]",

+ parseText("=?iso-8859-1?Q?Know_wh=E4t?_It_works!?=")

+ );

+

+ // With language specifier

+ VASSERT_EQ(

+ "7",

+ "[text: [[word: charset=US-ASCII, buffer=Keith Moore, lang=EN]]]",

+ parseText("=?US-ASCII*EN?Q?Keith_Moore?=")

+ );

+ }

+

+ void testGenerate() {

+

+ // TODO

+

+ // With language specifier

+ vmime::word wlang1("Émeline", vmime::charset("UTF-8"), "FR");

+ VASSERT_EQ("lang1", "=?UTF-8*FR?Q?=C3=89meline?=", wlang1.generate());

+

+ vmime::word wlang2("Keith Moore", vmime::charset("US-ASCII"), "EN");

+ VASSERT_EQ("lang2", "=?US-ASCII*EN?Q?Keith_Moore?=", wlang2.generate());

+ }

+

+ void testDisplayForm() {

+

+#define DISPLAY_FORM(x) getDisplayText(*vmime::text::decodeAndUnfold(x))

+

+ // From RFC-2047

+ VASSERT_EQ("1", "a", DISPLAY_FORM("=?ISO-8859-1?Q?a?="));

+ VASSERT_EQ("2", "a b", DISPLAY_FORM("=?ISO-8859-1?Q?a?= b"));

+ VASSERT_EQ("3", "ab", DISPLAY_FORM("=?ISO-8859-1?Q?a?= =?ISO-8859-1?Q?b?="));

+ VASSERT_EQ("4", "ab", DISPLAY_FORM("=?ISO-8859-1?Q?a?= \t =?ISO-8859-1?Q?b?="));

+ VASSERT_EQ("5", "ab", DISPLAY_FORM("=?ISO-8859-1?Q?a?= \r\n \t =?ISO-8859-1?Q?b?="));

+ VASSERT_EQ("6", "a b", DISPLAY_FORM("=?ISO-8859-1?Q?a_b?="));

+ VASSERT_EQ("7", "a b", DISPLAY_FORM("=?ISO-8859-1?Q?a?= =?ISO-8859-2?Q?_b?="));

+

+ // Some more tests...

+ VASSERT_EQ("8", "a b", DISPLAY_FORM(" a =?ISO-8859-1?Q?b?= "));

+ VASSERT_EQ("9", "a b ", DISPLAY_FORM(" \t =?ISO-8859-1?Q?a?= b "));

+ VASSERT_EQ("10", "a b", DISPLAY_FORM(" a\r\n\t b"));

+

+ VASSERT_EQ("11", "a b c", DISPLAY_FORM("a =?ISO-8859-1?Q?b?= c"));

+ VASSERT_EQ("12", "a b c ", DISPLAY_FORM("a =?ISO-8859-1?Q?b?= c "));

+ VASSERT_EQ("13", "a b c ", DISPLAY_FORM(" a =?ISO-8859-1?Q?b?= c "));

+ VASSERT_EQ("14", "a b c d", DISPLAY_FORM("a =?ISO-8859-1?Q?b?= c =?ISO-8859-1?Q?d?= "));

+ VASSERT_EQ("15", "a b c d e", DISPLAY_FORM("a =?ISO-8859-1?Q?b?= c =?ISO-8859-1?Q?d?= e"));

+

+ // Whitespaces and multiline

+ VASSERT_EQ("16", "a b c d e", DISPLAY_FORM("=?ISO-8859-1?Q?a_b_?=c\n\t=?ISO-8859-1?Q?d_?=e"));

+

+ // Ignored newlines

+ VASSERT_EQ("17", "ab", DISPLAY_FORM("=?ISO-8859-1?Q?a?=\r\nb"));

+ VASSERT_EQ("18", "a b", DISPLAY_FORM("=?ISO-8859-1?Q?a?= \r\nb"));

+

+#undef DISPLAY_FORM

+ }

+

+ void testWordConstructors() {

+

+ VASSERT_EQ("1.1", vmime::charset::getLocalCharset(), vmime::word().getCharset());

+ VASSERT_EQ("1.2", "", vmime::word().getBuffer());

+

+ VASSERT_EQ("2.1", vmime::charset::getLocalCharset(), vmime::word("foo").getCharset());

+ VASSERT_EQ("2.2", "foo", vmime::word("foo").getBuffer());

+

+ VASSERT_EQ("3.1", "bar", vmime::word("foo", vmime::charset("bar")).getCharset().getName());

+ VASSERT_EQ("3.2", "foo", vmime::word("foo", vmime::charset("bar")).getBuffer());

+ }

+

+ void testWordParse() {

+

+ // Simple encoded word

+ vmime::word w1;

+ w1.parse("=?foo?q?bar=E9 baz?=");

+

+ VASSERT_EQ("1.1", "foo", w1.getCharset().getName());

+ VASSERT_EQ("1.2", "bar\xe9 baz", w1.getBuffer());

+

+ // Unencoded text

+ vmime::word w2;

+ w2.parse(" foo bar \tbaz...");

+

+ VASSERT_EQ("2.1", vmime::charset(vmime::charsets::US_ASCII), w2.getCharset());

+ VASSERT_EQ("2.2", " foo bar \tbaz...", w2.getBuffer());

+

+ // Malformed word

+ vmime::word w3;

+ w3.parse("=?foo bar");

+

+ VASSERT_EQ("3.1", vmime::charset(vmime::charsets::US_ASCII), w3.getCharset());

+ VASSERT_EQ("3.2", "=?foo bar", w3.getBuffer());

+

+ // Unknown encoding

+ vmime::word w4;

+ w4.parse("=?whatever?not_q_or_b?whatever?=");

+

+ VASSERT_EQ("4.1", vmime::charset(vmime::charsets::US_ASCII), w4.getCharset());

+ VASSERT_EQ("4.2", "=?whatever?not_q_or_b?whatever?=", w4.getBuffer());

+ }

+

+ void testWordGenerate() {

+

+ VASSERT_EQ(

+ "1",

+ "=?foo?Q?bar=E9_baz?=",

+ vmime::word("bar\xe9 baz", vmime::charset("foo")).generate()

+ );

+

+ VASSERT_EQ(

+ "2",

+ "=?foo?B?8fLz9PU=?=",

+ vmime::word("\xf1\xf2\xf3\xf4\xf5", vmime::charset("foo")).generate()

+ );

+ }

+

+ void testWordGenerateSpace() {

+

+ // No white-space between an unencoded word and a encoded one

+ VASSERT_EQ(

+ "1",

+ "Bonjour =?utf-8?Q?Fran=C3=A7ois?=",

+ vmime::text::newFromString(

+ "Bonjour Fran\xc3\xa7ois",

+ vmime::charset("utf-8")

+ )->generate()

+ );

+

+ // White-space between two encoded words

+ vmime::text txt;

+ 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?=";

+

+ // -- test encoding

+ VASSERT_EQ("2", encoded, txt.generate());

+

+ // -- ensure no space is added when decoding

+ vmime::text txt2;

+ txt2.parse(encoded, 0, encoded.length());

+

+ VASSERT_EQ("3", decoded, txt2.getWholeBuffer());

+

+ // -- test rencoding

+ VASSERT_EQ("4", encoded, txt2.generate());

+ }

+

+ void testWordGenerateSpace2() {

+

+ // White-space between two encoded words (#2)

+ vmime::text txt;

+ 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";

+

+ // -- test encoding

+ VASSERT_EQ("1", encoded, txt.generate());

+

+ // -- ensure no space is added when decoding

+ vmime::text txt2;

+ txt2.parse(encoded, 0, encoded.length());

+

+ VASSERT_EQ("2", decoded, txt2.getWholeBuffer());

+

+ // -- test rencoding

+ VASSERT_EQ("3", encoded, txt2.generate());

+ }

+

+ void testWordGenerateMultiBytes() {

+

+ // Ensure we don't encode a non-integral number of characters

+ VASSERT_EQ(

+ "1",

+ "=?utf-8?Q?aaa?==?utf-8?Q?=C3=A9?==?utf-8?Q?zzz?=",

+ cleanGeneratedWords(

+ vmime::word("aaa\xc3\xa9zzz", vmime::charset("utf-8")).generate(16)

+ )

+ );

+

+ VASSERT_EQ(

+ "2",

+ "=?utf-8?Q?aaa=C3=A9?==?utf-8?Q?zzz?=",

+ cleanGeneratedWords(

+ vmime::word("aaa\xc3\xa9zzz", vmime::charset("utf-8")).generate(17)

+ )

+ );

+ }

+

+ void testWordGenerateQuote() {

+

+ std::string str;

+ vmime::utility::outputStreamStringAdapter os(str);

+

+ vmime::generationContext ctx;

+ ctx.setMaxLineLength(1000);

+

+ // ASCII-only text is quotable

+ str.clear();

+ vmime::word("Quoted text")

+ .generate(ctx, os, 0, NULL, vmime::text::QUOTE_IF_POSSIBLE, NULL);

+

+ VASSERT_EQ("1", "\"Quoted text\"", cleanGeneratedWords(str));

+

+ // Text with CR/LF is not quotable

+ str.clear();

+ vmime::word("Non-quotable\ntext", "us-ascii")

+ .generate(ctx, os, 0, NULL, vmime::text::QUOTE_IF_POSSIBLE, NULL);

+

+ VASSERT_EQ("2", "=?us-ascii?Q?Non-quotable=0Atext?=", cleanGeneratedWords(str));

+

+ // Text with non-ASCII chars is not quotable

+ str.clear();

+ vmime::word("Non-quotable text \xc3\xa9")

+ .generate(ctx, os, 0, NULL, vmime::text::QUOTE_IF_POSSIBLE, NULL);

+

+ VASSERT_EQ("3", "=?UTF-8?Q?Non-quotable_text_=C3=A9?=", cleanGeneratedWords(str));

+ }

+

+ void testWordGenerateSpecialCharsets() {

+

+ // ISO-2022-JP only uses 7-bit chars but should be encoded in Base64

+ VASSERT_EQ(

+ "1",

+ "=?iso-2022-jp?B?XlskQiVRITwlPSVKJWshJiU9JVUlSCUmJSclIl5bKEI=?=",

+ cleanGeneratedWords(

+ vmime::word(

+ "^[$B%Q!<%=%J%k!&%=%U%H%&%'%\"^[(B",

+ vmime::charset("iso-2022-jp")

+ ).generate(100)

+ )

+ );

+ }

+

+ void testWordGenerateSpecials() {

+

+ // In RFC-2047, quotation marks (ASCII 22h) should be encoded

+ VASSERT_EQ(

+ "1",

+ "=?UTF-8?Q?=22=C3=9Cml=C3=A4ute=22?=",

+ vmime::word(

+ "\x22\xC3\x9Cml\xC3\xA4ute\x22",

+ vmime::charset("UTF-8")

+ ).generate()

+ );

+ }

+

+ void testWhitespace() {

+

+ // Create

+ vmime::text text;

+ text.createFromString("Achim Br\xc3\xa4ndt", vmime::charsets::UTF_8);

+

+ VASSERT_EQ("1", 2, text.getWordCount());

+ VASSERT_EQ("2", "Achim ", text.getWordAt(0)->getBuffer());

+ VASSERT_EQ("3", "us-ascii", text.getWordAt(0)->getCharset());

+ VASSERT_EQ("4", "Br\xc3\xa4ndt", text.getWordAt(1)->getBuffer());

+ VASSERT_EQ("5", "utf-8", text.getWordAt(1)->getCharset());

+

+ // Generate

+ VASSERT_EQ("6", "Achim =?utf-8?Q?Br=C3=A4ndt?=", text.generate());

+

+ // Parse

+ text.parse("=?us-ascii?Q?Achim_?= =?utf-8?Q?Br=C3=A4ndt?=");

+

+ VASSERT_EQ("7", 2, text.getWordCount());

+ VASSERT_EQ("8", "Achim ", text.getWordAt(0)->getBuffer());

+ VASSERT_EQ("9", "us-ascii", text.getWordAt(0)->getCharset());

+ VASSERT_EQ("10", "Br\xc3\xa4ndt", text.getWordAt(1)->getBuffer());

+ VASSERT_EQ("11", "utf-8", text.getWordAt(1)->getCharset());

+ }

+

+ void testWhitespaceMBox() {

+

+ // Space MUST be encoded inside a word

+ vmime::mailbox mbox(vmime::text("Achim Br\xc3\xa4ndt", vmime::charsets::UTF_8), "me@vmime.org");

+ VASSERT_EQ("generate1", "=?us-ascii?Q?Achim_?= =?utf-8?Q?Br=C3=A4ndt?= <me@vmime.org>", mbox.generate());

+

+ vmime::text txt;

+ 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, "me@vmime.org");

+ VASSERT_EQ("generate2", "=?us-ascii?Q?Achim_?= =?utf-8?Q?Br=C3=A4ndt?= <me@vmime.org>", mbox.generate());

+

+ mbox.parse("=?us-ascii?Q?Achim?= =?utf-8?Q?Br=C3=A4ndt?= <me@vmime.org>");

+ VASSERT_EQ("parse.name.count", 2, mbox.getName().getWordCount());

+ VASSERT_EQ("parse.name.word1.buffer", "Achim", mbox.getName().getWordAt(0)->getBuffer());

+ VASSERT_EQ("parse.name.word1.charset", "us-ascii", mbox.getName().getWordAt(0)->getCharset());

+ VASSERT_EQ("parse.name.word2.buffer", "Br\xc3\xa4ndt", mbox.getName().getWordAt(1)->getBuffer());

+ VASSERT_EQ("parse.name.word2.charset", "utf-8", mbox.getName().getWordAt(1)->getCharset());

+

+ VASSERT_EQ("parse.email", "me@vmime.org", mbox.getEmail());

+ }

+

+ void testFoldingAscii() {

+

+ // In this test, no encoding is needed, but line should be folded anyway

+ vmime::word w("01234567890123456789012345678901234567890123456789"

+ "01234567890123456789012345678901234567890123456789", vmime::charset("us-ascii"));

+

+ VASSERT_EQ(

+ "fold.ascii",

+ "=?us-ascii?Q?01234567890123456789012345678901234?=\r\n"

+ " =?us-ascii?Q?5678901234567890123456789012345678?=\r\n"

+ " =?us-ascii?Q?9012345678901234567890123456789?=", w.generate(50)

+ );

+ }

+

+ void testForcedNonEncoding() {

+

+ // Testing long unbreakable and unencodable header

+ vmime::relay r;

+ r.parse(

+ " from User (Ee9GMqZQ8t7IQwftfAFHd2KyScCYRrFSJ50tKEoXv2bVCG4HcPU80GGWiFabAvG77FekpGgF1h@[127.0.0.1]) by servername.hostname.com\n\t"

+ "with esmtp id 1NGTS9-2C0sqG0; Fri, 4 Dec 2009 09:23:49 +0100"

+ );

+

+ VASSERT_EQ(

+ "received.long",

+ "from User\r\n (Ee9GMqZQ8t7IQwftfAFHd2KyScCYRrFSJ50tKEoXv2bVCG4HcPU80GGWiFabAvG77FekpGgF1h@[127.0.0.1])\r\n by servername.hostname.com with esmtp id 1NGTS9-2C0sqG0; Fri, 4 Dec 2009\r\n 09:23:49 +0100",

+ r.generate(78)

+ );

+ }

+

+ void testBugFix20110511() {

+

+ /*

+

+ Using the latest version of vmime (0.9.1), encoding the following string: Jean

+ Gwenaël Dutourd will result in:

+ Jean =?utf-8?Q?Gwena=C3=ABl_?= Dutourd

+ However, decoding this will result in Jean Gwenaël Dutourd (notice two spaces

+ between the last 2 words). The encoder adds a _ after the second word, but

+ since the last word is not encoded, the space between them is not ignored, and

+ is decoded into an additional space.

+

+ See: http://sourceforge.net/projects/vmime/forums/forum/237357/topic/4531365

+

+ */

+

+ const std::string DECODED_TEXT = "Jean Gwenaël Dutourd";

+ const std::string ENCODED_TEXT = "Jean =?utf-8?Q?Gwena=C3=ABl?= Dutourd";

+

+ // Encode

+ VASSERT_EQ(

+ "encode",

+ ENCODED_TEXT,

+ vmime::text::newFromString(DECODED_TEXT, vmime::charset("utf-8"))->generate()

+ );

+

+ // Decode

+ vmime::text t;

+ t.parse(ENCODED_TEXT);

+

+ // -- words

+ std::ostringstream oss; oss << t;

+ VASSERT_EQ(

+ "decode1",

+ "[text: [[word: charset=us-ascii, buffer=Jean ],"

+ "[word: charset=utf-8, buffer=Gwenaël],"

+ "[word: charset=us-ascii, buffer= Dutourd]]]",

+ oss.str()

+ );

+

+ // -- getWholeBuffer

+ VASSERT_EQ("decode2", DECODED_TEXT, t.getWholeBuffer());

+ }

+

+ void testInternationalizedEmail_specialChars() {

+

+ vmime::generationContext ctx(vmime::generationContext::getDefaultContext());

+ ctx.setInternationalizedEmailSupport(true);

+

+ vmime::generationContext::switcher <vmime::generationContext> contextSwitcher(ctx);

+

+ // Special sequence/chars should still be encoded

+ VASSERT_EQ(

+ "1",

+ "=?us-ascii?Q?Test=3D=3Frfc2047_sequence?=",

+ vmime::word("Test=?rfc2047 sequence", vmime::charset("us-ascii")).generate()

+ );

+

+ VASSERT_EQ(

+ "2",

+ "=?us-ascii?Q?Line_One=0ALine_Two?=",

+ vmime::word("Line One\nLine Two", vmime::charset("us-ascii")).generate()

+ );

+ }

+

+ void testInternationalizedEmail_UTF8() {

+

+ vmime::generationContext ctx(vmime::generationContext::getDefaultContext());

+ ctx.setInternationalizedEmailSupport(true);

+

+ vmime::generationContext::switcher <vmime::generationContext> contextSwitcher(ctx);

+

+ // Already UTF-8 encoded text should be left as is

+ VASSERT_EQ(

+ "1", "Achim Br\xc3\xa4ndt",

+ vmime::word("Achim Br\xc3\xa4ndt", vmime::charset("utf-8")).generate()

+ );

+ }

+

+ void testInternationalizedEmail_nonUTF8() {

+

+ vmime::generationContext ctx(vmime::generationContext::getDefaultContext());

+ ctx.setInternationalizedEmailSupport(true);

+

+ vmime::generationContext::switcher <vmime::generationContext> contextSwitcher(ctx);

+

+ // Non UTF-8 encoded text should first be converted to UTF-8

+ VASSERT_EQ(

+ "1", "Achim Br\xc3\xa4ndt",

+ vmime::word("Achim Br\xe4ndt", vmime::charset("iso-8859-1")).generate()

+ );

+ }

+

+ void testInternationalizedEmail_folding() {

+

+ vmime::generationContext ctx(vmime::generationContext::getDefaultContext());

+ ctx.setInternationalizedEmailSupport(true);

+

+ vmime::generationContext::switcher <vmime::generationContext> contextSwitcher(ctx);

+

+ // RFC-2047 encoding must be performed, as line folding is needed

+ vmime::word w1("01234567890123456789\xc3\xa0x012345678901234567890123456789"

+ "01234567890123456789\xc3\xa0x012345678901234567890123456789", vmime::charset("utf-8"));

+

+ VASSERT_EQ(

+ "1",

+ "=?utf-8?Q?01234567890123456789=C3=A0x01234567890?=\r\n"

+ " =?utf-8?Q?1234567890123456789012345678901234567?=\r\n"

+ " =?utf-8?Q?89=C3=A0x0123456789012345678901234567?=\r\n"

+ " =?utf-8?Q?89?=",

+ w1.generate(50)

+ );

+

+ // RFC-2047 encoding will not be forced, as words can be wrapped in a new line

+ vmime::word w2("bla bla bla This is some '\xc3\xa0\xc3\xa7' UTF-8 encoded text", vmime::charset("utf-8"));

+

+ VASSERT_EQ(

+ "2",

+ "bla bla bla This is\r\n"

+ " some '\xc3\xa0\xc3\xa7' UTF-8\r\n"

+ " encoded text",

+ w2.generate(20)

+ );

+ }

+

+ void testInternationalizedEmail_whitespace() {

+

+ // Sanity checks for running this test

+ {

+ vmime::text t;

+ t.parse("=?utf-8?Q?Adquisi=C3=B3n?= de Laptop y celular");

+

+ VASSERT_EQ("parse", "Adquisión de Laptop y celular", t.getWholeBuffer());

+ }

+

+ {

+ vmime::text t("Adquisi\xc3\xb3n de Laptop y celular", vmime::charset("UTF-8"));

+

+ VASSERT_EQ("generate", "=?UTF-8?Q?Adquisi=C3=B3n?= de Laptop y celular", t.generate());

+ }

+

+ // Ensure a whitespace is added between encoded words in intl email support enabled

+ {

+ vmime::text t;

+ t.parse("=?utf-8?Q?Adquisi=C3=B3n?= de Laptop y celular");

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter ossAdapter(oss);

+ vmime::generationContext gctx(vmime::generationContext::getDefaultContext());

+ gctx.setInternationalizedEmailSupport(true);

+ t.generate(gctx, ossAdapter);

+

+ VASSERT_EQ("generate", "Adquisi\xc3\xb3n de Laptop y celular", oss.str());

+ }

+

+ {

+ vmime::text t;

+ t.parse("=?utf-8?Q?Adquisi=C3=B3n?= de Laptop =?utf-8?Q?y?= celular");

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter ossAdapter(oss);

+ vmime::generationContext gctx(vmime::generationContext::getDefaultContext());

+ gctx.setInternationalizedEmailSupport(true);

+ t.generate(gctx, ossAdapter);

+

+ VASSERT_EQ("generate", "Adquisi\xc3\xb3n de Laptop y celular", oss.str());

+ }

+

+ {

+ vmime::text t;

+ t.parse("=?utf-8?Q?Adquisi=C3=B3n?= de Laptop =?utf-8?Q?y_celular?=");

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter ossAdapter(oss);

+ vmime::generationContext gctx(vmime::generationContext::getDefaultContext());

+ gctx.setInternationalizedEmailSupport(true);

+ t.generate(gctx, ossAdapter);

+

+ VASSERT_EQ("generate", "Adquisi\xc3\xb3n de Laptop y celular", oss.str());

+ }

+

+ // Ensure no whitespace is added with non-encoded words

+ {

+ vmime::text t;

+ t.parse("Laptop y celular");

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter ossAdapter(oss);

+ vmime::generationContext gctx(vmime::generationContext::getDefaultContext());

+ gctx.setInternationalizedEmailSupport(true);

+ t.generate(gctx, ossAdapter);

+

+ VASSERT_EQ("generate", "Laptop y celular", oss.str());

+ }

+

+ {

+ vmime::text t;

+ t.parse("=?utf-8?Q?Laptop_y_celular?=");

+

+ std::ostringstream oss;

+ vmime::utility::outputStreamAdapter ossAdapter(oss);

+ vmime::generationContext gctx(vmime::generationContext::getDefaultContext());

+ gctx.setInternationalizedEmailSupport(true);

+ t.generate(gctx, ossAdapter);

+

+ VASSERT_EQ("generate", "Laptop y celular", oss.str());

+ }

+ }

+

+ void testWronglyPaddedB64Words() {

+

+ vmime::text outText;

+

+ vmime::text::decodeAndUnfold("=?utf-8?B?5Lit5?=\n =?utf-8?B?paH?=", &outText);

+

+ VASSERT_EQ(

+ "1",

+ "\xe4\xb8\xad\xe6\x96\x87",

+ outText.getConvertedText(vmime::charset("utf-8"))

+ );

+

+ vmime::text::decodeAndUnfold("=?utf-8?B?5Lit5p?=\n =?utf-8?B?aH?=", &outText);

+

+ VASSERT_EQ(

+ "2",

+ "\xe4\xb8\xad\xe6\x96\x87",

+ outText.getConvertedText(vmime::charset("utf-8"))

+ );

+

+ vmime::text::decodeAndUnfold("=?utf-8?B?5Lit5pa?=\n =?utf-8?B?H?=", &outText);

+

+ VASSERT_EQ(

+ "3",

+ "\xe4\xb8\xad\xe6\x96\x87",

+ outText.getConvertedText(vmime::charset("utf-8"))

+ );

+ }

+

+ // Ensure that words which encode a non-integral number of characters

+ // are correctly decoded.

+ void testFixBrokenWords() {

+

+ vmime::text outText;

+

+ vmime::charsetConverterOptions opts;

+ opts.silentlyReplaceInvalidSequences = false; // just to be sure that broken words are actually fixed

+

+ // Test case 1

+ vmime::text::decodeAndUnfold(

+ "=?utf-8?Q?Gwena=C3?="

+ "=?utf-8?Q?=ABl?=",

+ &outText

+ );

+

+ VASSERT_EQ("1.1", 1, outText.getWordCount());

+ VASSERT_EQ("1.2", "Gwena\xc3\xabl", outText.getWordAt(0)->getBuffer());

+ VASSERT_EQ("1.3", vmime::charset("utf-8"), outText.getWordAt(0)->getCharset());

+

+ // Test case 2

+ vmime::text::decodeAndUnfold(

+ "=?utf-8?B?5Lit6Yu85qmf5qKw6JGj5LqL5pyDMTAz5bm056ysMDXlsYbn?="

+ "=?utf-8?B?rKwwN+asoeitsOeoiw==?=",

+ &outText

+ );

+

+ VASSERT_EQ("2.1", 1, outText.getWordCount());

+ VASSERT_EQ("2.2", "\xe4\xb8\xad\xe9\x8b\xbc\xe6\xa9\x9f\xe6\xa2\xb0"

+ "\xe8\x91\xa3\xe4\xba\x8b\xe6\x9c\x83\x31\x30\x33\xe5\xb9\xb4"

+ "\xe7\xac\xac\x30\x35\xe5\xb1\x86\xe7\xac\xac\x30\x37\xe6\xac"

+ "\xa1\xe8\xad\xb0\xe7\xa8\x8b", outText.getWordAt(0)->getBuffer());

+ VASSERT_EQ("2.3", vmime::charset("utf-8"), outText.getWordAt(0)->getCharset());

+

+ // Test case 3 (a character spanning over 3 words: 'を' = E3 82 92)

+ vmime::text::decodeAndUnfold(

+ "=?utf-8?Q?abc=E3?="

+ "=?utf-8?Q?=82?="

+ "=?utf-8?Q?=92xyz?=",

+ &outText

+ );

+

+ VASSERT_EQ("3.1", 1, outText.getWordCount());

+ VASSERT_EQ("3.2", "abc\xe3\x82\x92xyz", outText.getWordAt(0)->getBuffer());

+ VASSERT_EQ("3.3", vmime::charset("utf-8"), outText.getWordAt(0)->getCharset());

+

+ // Test case 4 (remains invalid)

+ vmime::text::decodeAndUnfold(

+ "=?utf-8?Q?abc=E3?="

+ "=?utf-8?Q?=82?="

+ "=?utf-8?Q?xy?="

+ "=?utf-8?Q?z?=",

+ &outText

+ );

+

+ VASSERT_EQ("4.1", 2, outText.getWordCount());

+ VASSERT_EQ("4.2", "abc", outText.getWordAt(0)->getBuffer());

+ VASSERT_EQ("4.3", vmime::charset("utf-8"), outText.getWordAt(0)->getCharset());

+ VASSERT_EQ("4.4", "\xe3\x82xyz", outText.getWordAt(1)->getBuffer());

+ VASSERT_EQ("4.5", vmime::charset("utf-8"), outText.getWordAt(1)->getCharset());

+

+ // Test case 5 (remains partially invalid)

+ vmime::text::decodeAndUnfold(

+ "=?utf-8?Q?abc=E3?="

+ "=?utf-8?Q?=82?="

+ "=?utf-8?Q?\x92xy?="

+ "=?utf-8?Q?z\xc3?=",

+ &outText

+ );

+

+ VASSERT_EQ("5.1", 2, outText.getWordCount());

+ VASSERT_EQ("5.2", "abc\xe3\x82\x92xyz", outText.getWordAt(0)->getBuffer());

+ VASSERT_EQ("5.3", vmime::charset("utf-8"), outText.getWordAt(0)->getCharset());

+ VASSERT_EQ("5.4", "\xc3", outText.getWordAt(1)->getBuffer());

+ VASSERT_EQ("5.5", vmime::charset("utf-8"), outText.getWordAt(1)->getCharset());

+ }

+

+ void testUnknownCharset() {

+

+ vmime::text t;

+ vmime::text::decodeAndUnfold("=?gb2312?B?wdaRY8PA?=", &t);

+

+ VASSERT_EQ("1.1", 1, t.getWordCount());

+ VASSERT_EQ("1.2", "\xc1\xd6\x91\x63\xc3\xc0", t.getWordAt(0)->getBuffer());

+ VASSERT_EQ("1.3", vmime::charset("gb2312"), t.getWordAt(0)->getCharset());

+

+

+

+ vmime::parsingContext ctx;

+

+ const vmime::string hfieldBuffer = "From: '=?gb2312?B?wdaRY8PA?=' <a.b@c.de>";

+

+ vmime::shared_ptr <vmime::headerField> hfield =

+ vmime::headerField::parseNext(ctx, hfieldBuffer, 0, hfieldBuffer.size());

+

+ vmime::shared_ptr <vmime::mailbox> hvalue =

+ hfield->getValue <vmime::mailbox>();

+

+ VASSERT_EQ("2.1", 3, hvalue->getName().getWordCount());

+ VASSERT_EQ("2.2", "'", hvalue->getName().getWordAt(0)->getBuffer());

+ VASSERT_EQ("2.3", vmime::charset("us-ascii"), hvalue->getName().getWordAt(0)->getCharset());

+ VASSERT_EQ("2.4", "\xc1\xd6\x91\x63\xc3\xc0", hvalue->getName().getWordAt(1)->getBuffer());

+ VASSERT_EQ("2.5", vmime::charset("gb2312"), hvalue->getName().getWordAt(1)->getCharset());

+ VASSERT_EQ("2.6", "'", hvalue->getName().getWordAt(2)->getBuffer());

+ VASSERT_EQ("2.7", vmime::charset("us-ascii"), hvalue->getName().getWordAt(2)->getCharset());

+ }

+

+VMIME_TEST_SUITE_END

+//

+// VMime library (http://www.vmime.org)

+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License as

+// published by the Free Software Foundation; either version 3 of

+// the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+// General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License along

+// with this program; if not, write to the Free Software Foundation, Inc.,

+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// Linking this library statically or dynamically with other modules is making

+// a combined work based on this library. Thus, the terms and conditions of

+// the GNU General Public License cover the whole combination.

+//

+

+#include "tests/testUtils.hpp"

+

+#include "vmime/wordEncoder.hpp"

+

+

+VMIME_TEST_SUITE_BEGIN(wordEncoderTest)

+

+ VMIME_TEST_LIST_BEGIN

+ VMIME_TEST(testGetNextChunk)

+ VMIME_TEST(testGetNextChunk_integral)

+ VMIME_TEST(testIsEncodingNeeded_ascii)

+ VMIME_TEST(testIsEncodingNeeded_withLanguage)

+ VMIME_TEST(testIsEncodingNeeded_specialChars)

+ VMIME_TEST(testGuessBestEncoding_QP)

+ VMIME_TEST(testGuessBestEncoding_B64)

+ VMIME_TEST(testEncodeQP_RFC2047)

+ VMIME_TEST_LIST_END

+

+

+ void testGetNextChunk() {

+

+ // An integral number of characters should be encoded

+ vmime::wordEncoder we(

+ "bufferfoobarbaz",

+ vmime::charset("utf-8"),

+ vmime::wordEncoder::ENCODING_AUTO

+ );

+

+ VASSERT_EQ("1", "buffer", we.getNextChunk(6));

+ VASSERT_EQ("2", "foo", we.getNextChunk(3));

+ VASSERT_EQ("3", "barbaz", we.getNextChunk(10));

+ }

+

+ void testGetNextChunk_integral() {

+

+ // An integral number of characters should be encoded

+ vmime::wordEncoder we(

+ "buffer\xc3\xa0plop",

+ vmime::charset("utf-8"),

+ vmime::wordEncoder::ENCODING_AUTO

+ );

+

+ VASSERT_EQ("1", "buffer=C3=A0", we.getNextChunk(7));

+ VASSERT_EQ("2", "plop", we.getNextChunk(10));

+ }

+

+ void testIsEncodingNeeded_ascii() {

+

+ vmime::generationContext ctx(vmime::generationContext::getDefaultContext());

+ ctx.setInternationalizedEmailSupport(false);

+

+ VASSERT_FALSE(

+ "ascii",

+ vmime::wordEncoder::isEncodingNeeded(

+ ctx, "ASCII-only buffer", vmime::charset("utf-8"), ""

+ )

+ );

+

+ VASSERT_TRUE(

+ "non-ascii",

+ vmime::wordEncoder::isEncodingNeeded(

+ ctx, "Buffer with some UTF-8 '\xc3\xa0'", vmime::charset("utf-8"), ""

+ )

+ );

+ }

+

+ void testIsEncodingNeeded_withLanguage() {

+

+ VASSERT_TRUE(

+ "ascii",

+ vmime::wordEncoder::isEncodingNeeded(

+ vmime::generationContext::getDefaultContext(),

+ "ASCII-only buffer",

+ vmime::charset("utf-8"),

+ "en"

+ )

+ );

+ }

+

+ void testIsEncodingNeeded_specialChars() {

+

+ VASSERT_TRUE(

+ "rfc2047",

+ vmime::wordEncoder::isEncodingNeeded(

+ vmime::generationContext::getDefaultContext(),

+ "foo bar =? foo bar",

+ vmime::charset("us-ascii"),

+ ""

+ )

+ );

+

+ VASSERT_TRUE(

+ "new line 1",

+ vmime::wordEncoder::isEncodingNeeded(

+ vmime::generationContext::getDefaultContext(),

+ "foo bar \n foo bar",

+ vmime::charset("us-ascii"),

+ ""

+ )

+ );

+

+ VASSERT_TRUE(

+ "new line 2",

+ vmime::wordEncoder::isEncodingNeeded(

+ vmime::generationContext::getDefaultContext(),

+ "foo bar \r foo bar",

+ vmime::charset("us-ascii"),

+ ""

+ )

+ );

+ }

+

+ void testGuessBestEncoding_QP() {

+

+ VASSERT_EQ(

+ "1",

+ vmime::wordEncoder::ENCODING_QP,

+ vmime::wordEncoder::guessBestEncoding("ASCII only buffer", vmime::charset("us-ascii"))

+ );

+ }

+

+ void testGuessBestEncoding_B64() {

+

+ // >= 40% non-ASCII => Base64...

+ VASSERT_EQ(

+ "1",

+ vmime::wordEncoder::ENCODING_B64,

+ vmime::wordEncoder::guessBestEncoding("xxxxx\xc3\xa0\xc3\xa0", vmime::charset("utf-8"))

+ );

+

+ // ...else Quoted-Printable

+ VASSERT_EQ(

+ "2",

+ vmime::wordEncoder::ENCODING_QP,

+ vmime::wordEncoder::guessBestEncoding("xxxxxx\xc3\xa0\xc3\xa0", vmime::charset("utf-8"))

+ );

+ }

+

+ void testEncodeQP_RFC2047() {

+

+ // When Quoted-Printable is used, it should be RFC-2047 QP encoding

+ vmime::wordEncoder we(

+ "buffer\xc3\xa0 foo_bar",

+ vmime::charset("utf-8"),

+ vmime::wordEncoder::ENCODING_AUTO

+ );

+

+ VASSERT_EQ("1", "buffer=C3=A0_foo=5Fbar", we.getNextChunk(100));

+ }

+

+VMIME_TEST_SUITE_END