GpgFrontend/vmime
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Unit tests for content handlers.

Browse Source
This commit is contained in:
Vincent Richard 2013-06-26 21:41:42 +02:00
parent 76f88f9cdd
commit 1a30cfe41b
6 changed files with 613 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
SConstruct
View File

@ -368,6 +368,8 @@ libvmimetest_sources = [
'tests/parser/datetimeTest.cpp',
'tests/parser/dispositionTest.cpp',
'tests/parser/emailAddressTest.cpp',
'tests/parser/emptyContentHandlerTest.cpp',
'tests/parser/fileContentHandlerTest.cpp',
'tests/parser/headerTest.cpp',
'tests/parser/headerFieldTest.cpp',
'tests/parser/htmlTextPartTest.cpp',
@ -379,6 +381,8 @@ libvmimetest_sources = [
'tests/parser/messageTest.cpp',
'tests/parser/pathTest.cpp',
'tests/parser/parameterTest.cpp',
'tests/parser/streamContentHandlerTest.cpp',
'tests/parser/stringContentHandlerTest.cpp',
'tests/parser/textTest.cpp',
'tests/parser/wordEncoderTest.cpp',
# ============================== Utility =============================

99
tests/parser/emptyContentHandlerTest.cpp Normal file
View File

@ -0,0 +1,99 @@
//
// VMime library (http://www.vmime.org)
// Copyright (C) 2002-2013 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

132
tests/parser/fileContentHandlerTest.cpp Normal file
View File

@ -0,0 +1,132 @@
//
// VMime library (http://www.vmime.org)
// Copyright (C) 2002-2013 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::ref <vmime::utility::file> testFile;
vmime::string testDataEncoded, testDataDecoded;
void setUp()
{
testDataDecoded = "ABCDEFGHIJKLMNOPQRSTUVWXYZ \x12\x34\x56\x78\x90 abcdefghijklmnopqrstuvwxyz0123456789";
testDataEncoded = "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogEjRWeJAgYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5";
//printf("\n %s \n", encode("base64", testDataDecoded).c_str());
std::ostringstream testFilePath;
testFilePath << "/tmp/vmime_test_" << (rand() % 999999999);
vmime::ref <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 = 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

185
tests/parser/streamContentHandlerTest.cpp Normal file
View File

@ -0,0 +1,185 @@
//
// VMime library (http://www.vmime.org)
// Copyright (C) 2002-2013 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::ref <vmime::utility::inputStream> stream =
vmime::create <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::ref <vmime::utility::inputStream> stream =
vmime::create <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::ref <vmime::utility::inputStream> stream2 =
vmime::create <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::ref <vmime::utility::inputStream> stream =
vmime::create <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::ref <vmime::utility::inputStream> stream =
vmime::create <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::ref <vmime::utility::inputStream> stream =
vmime::create <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::ref <vmime::utility::inputStream> stream =
vmime::create <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::ref <vmime::utility::inputStream> stream =
vmime::create <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::ref <vmime::utility::inputStream> stream =
vmime::create <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

184
tests/parser/stringContentHandlerTest.cpp Normal file
View File

@ -0,0 +1,184 @@
//
// VMime library (http://www.vmime.org)
// Copyright (C) 2002-2013 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(testStringProxy)
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());
}
void testStringProxy()
{
// With 'stringProxy' object
vmime::utility::stringProxy str("This is the data buffer", 12, 12 + 4);
vmime::stringContentHandler cth(str);
VASSERT_FALSE("empty", cth.isEmpty());
VASSERT_EQ("length", 4, cth.getLength());
std::ostringstream oss;
vmime::utility::outputStreamAdapter osa(oss);
cth.extract(osa);
VASSERT_EQ("extract", "data", oss.str());
// Directly with constructor
vmime::stringContentHandler cth2("This is the data buffer", 12, 12 + 4);
VASSERT_FALSE("empty", cth2.isEmpty());
VASSERT_EQ("length", 4, cth2.getLength());
std::ostringstream oss2;
vmime::utility::outputStreamAdapter osa2(oss2);
cth2.extract(osa2);
VASSERT_EQ("extract", "data", oss2.str());
}
VMIME_TEST_SUITE_END

10
tests/testUtils.hpp
View File

@ -84,7 +84,7 @@
static AutoRegisterModule <VMIME_TEST_SUITE> autoRegisterModule;
#define VMIME_TEST_LIST_BEGIN CPPUNIT_TEST_SUITE(VMIME_TEST_SUITE);
#define VMIME_TEST_LIST_END CPPUNIT_TEST_SUITE_END();
#define VMIME_TEST_LIST_END CPPUNIT_TEST_SUITE_END(); public:
#define VMIME_TEST(name) CPPUNIT_TEST(name);
@ -221,6 +221,14 @@ inline std::ostream& operator<<(std::ostream& os, const vmime::datetime& d)
}
inline std::ostream& operator<<(std::ostream& os, const vmime::encoding& enc)
{
os << enc.generate();
return (os);
}
}