[wxWidgets.git] / tests / base64 / base64.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/base64/base64.cpp
// Purpose:     wxBase64Encode/Decode unit test
// Author:      Charles Reimers
// Created:     2007-06-22
// RCS-ID:      $Id$
///////////////////////////////////////////////////////////////////////////////

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif // WX_PRECOMP

#if wxUSE_BASE64

#include "wx/base64.h"

static const char encoded0to255[] =
    "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIj"
    "JCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZH"
    "SElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWpr"
    "bG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6P"
    "kJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKz"
    "tLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX"
    "2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7"
    "/P3+/w==";

static void
generatePatternedData(void* buff, size_t len, unsigned char startVal,
                      unsigned char addVal, unsigned char multVal = 1,
                      unsigned char xorMask = 0, unsigned char andMask = 255)
{
    unsigned char *cbuff = (unsigned char *)buff;
    unsigned char curval = startVal;
    while(len--)
    {
        *(cbuff++) = curval;
        curval = (((curval + addVal) * multVal) ^ xorMask) & andMask;
    }
}

static void generateRandomData(void* buff, size_t len)
{
    unsigned char *cbuff = (unsigned char *)buff;
    while(len--)
    {
        *(cbuff++) = (unsigned char)(((rand() * 255) / RAND_MAX));
    }
}

static void generateGibberish(void* buff, size_t len)
{
    static const unsigned char cb64[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    unsigned char *cbuff = (unsigned char *)buff;
    while(len--)
    {
        *(cbuff++) = cb64[((rand() * 64) / RAND_MAX)];
    }
}

// --------------------------------------------------------------------------
// test class
// --------------------------------------------------------------------------

class Base64TestCase : public CppUnit::TestCase
{
public:
    Base64TestCase() { }

private:
    CPPUNIT_TEST_SUITE( Base64TestCase );
        CPPUNIT_TEST( EncodeDecodeEmpty );
        CPPUNIT_TEST( EncodeDecodeA );
        CPPUNIT_TEST( EncodeDecodeAB );
        CPPUNIT_TEST( EncodeDecodeABC );
        CPPUNIT_TEST( EncodeDecodeABCD );
        CPPUNIT_TEST( EncodeDecode0to255 );
        CPPUNIT_TEST( EncodeDecodePatternA );
        CPPUNIT_TEST( EncodeDecodePatternB );
        CPPUNIT_TEST( EncodeDecodePatternC );
        CPPUNIT_TEST( EncodeDecodeRandom );
        CPPUNIT_TEST( DecodeInvalid );
    CPPUNIT_TEST_SUITE_END();

    void EncodeDecodeEmpty();
    void EncodeDecodeA();
    void EncodeDecodeAB();
    void EncodeDecodeABC();
    void EncodeDecodeABCD();
    void EncodeDecode0to255();
    void EncodeDecodePatternA();
    void EncodeDecodePatternB();
    void EncodeDecodePatternC();
    void EncodeDecodeRandom();
    void DecodeInvalid();

    DECLARE_NO_COPY_CLASS(Base64TestCase)
};

// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( Base64TestCase );

// also include in its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( Base64TestCase, "Base64TestCase" );

void Base64TestCase::EncodeDecodeEmpty()
{
    char shouldBeEmpty[10];
    shouldBeEmpty[0] = '\0';
    size_t len = 10;

    CPPUNIT_ASSERT(wxBase64Encode(shouldBeEmpty, len, "", 0) != wxCONV_FAILED);
    CPPUNIT_ASSERT_EQUAL('\0', shouldBeEmpty[0]);

    CPPUNIT_ASSERT(wxBase64Decode(shouldBeEmpty, len, "") != wxCONV_FAILED);
    CPPUNIT_ASSERT_EQUAL('\0', shouldBeEmpty[0]);

    wxMemoryBuffer bufmt;
    wxString resultEmpty = wxBase64Encode(bufmt);
    CPPUNIT_ASSERT(resultEmpty.empty());

    bufmt = wxBase64Decode(resultEmpty);
    CPPUNIT_ASSERT_EQUAL(0, bufmt.GetDataLen());
}

void Base64TestCase::EncodeDecodeA()
{
    const wxString str = wxBase64Encode("A", 1);
    CPPUNIT_ASSERT_EQUAL(wxString("QQ=="), str);

    wxMemoryBuffer buf = wxBase64Decode(str);
    CPPUNIT_ASSERT_EQUAL(1, buf.GetDataLen());
    CPPUNIT_ASSERT_EQUAL('A', *(char *)buf.GetData());

    char cbuf[10];
    memset(cbuf, (char)-1, sizeof(cbuf));
    CPPUNIT_ASSERT_EQUAL( 1, wxBase64Decode(cbuf, 1, str) );
    CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
    CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[1] );
    CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[2] );
}

void Base64TestCase::EncodeDecodeAB()
{
    const wxString str = wxBase64Encode("AB", 2);
    CPPUNIT_ASSERT_EQUAL(wxString("QUI="), str);

    wxMemoryBuffer buf = wxBase64Decode(str);
    CPPUNIT_ASSERT_EQUAL(2, buf.GetDataLen());
    CPPUNIT_ASSERT_EQUAL('A', buf[0]);
    CPPUNIT_ASSERT_EQUAL('B', buf[1]);

    char cbuf[10];
    memset(cbuf, (char)-1, sizeof(cbuf));
    CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, wxBase64Decode(cbuf, 1, str) );
    CPPUNIT_ASSERT_EQUAL( 2, wxBase64Decode(cbuf, 2, str) );
    CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
    CPPUNIT_ASSERT_EQUAL( 'B', cbuf[1] );
    CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[2] );
    CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[3] );
}

void Base64TestCase::EncodeDecodeABC()
{
    const wxString str = wxBase64Encode("ABC", 3);
    CPPUNIT_ASSERT_EQUAL(wxString("QUJD"), str);

    wxMemoryBuffer buf = wxBase64Decode(str);
    CPPUNIT_ASSERT_EQUAL(3, buf.GetDataLen());
    CPPUNIT_ASSERT_EQUAL('A', buf[0]);
    CPPUNIT_ASSERT_EQUAL('B', buf[1]);
    CPPUNIT_ASSERT_EQUAL('C', buf[2]);

    char cbuf[10];
    memset(cbuf, (char)-1, sizeof(cbuf));
    CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, wxBase64Decode(cbuf, 2, str) );
    CPPUNIT_ASSERT_EQUAL( 3, wxBase64Decode(cbuf, 3, str) );
    CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
    CPPUNIT_ASSERT_EQUAL( 'B', cbuf[1] );
    CPPUNIT_ASSERT_EQUAL( 'C', cbuf[2] );
    CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[3] );
    CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[4] );
}

void Base64TestCase::EncodeDecodeABCD()
{
    const wxString str = wxBase64Encode("ABCD", 4);
    CPPUNIT_ASSERT_EQUAL(wxString("QUJDRA=="), str);

    wxMemoryBuffer buf = wxBase64Decode(str);
    CPPUNIT_ASSERT_EQUAL(4, buf.GetDataLen());
    CPPUNIT_ASSERT_EQUAL('A', buf[0]);
    CPPUNIT_ASSERT_EQUAL('B', buf[1]);
    CPPUNIT_ASSERT_EQUAL('C', buf[2]);
    CPPUNIT_ASSERT_EQUAL('D', buf[3]);

    char cbuf[10];
    memset(cbuf, (char)-1, sizeof(cbuf));
    CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, wxBase64Decode(cbuf, 3, str) );
    CPPUNIT_ASSERT_EQUAL( 4, wxBase64Decode(cbuf, 4, str) );
    CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
    CPPUNIT_ASSERT_EQUAL( 'B', cbuf[1] );
    CPPUNIT_ASSERT_EQUAL( 'C', cbuf[2] );
    CPPUNIT_ASSERT_EQUAL( 'D', cbuf[3] );
    CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[4] );
    CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[5] );
}

void Base64TestCase::EncodeDecode0to255()
{
    unsigned char buff[256];
    generatePatternedData(buff, 256, 0, 1);
    wxString str = wxBase64Encode(buff, 256);
    wxMemoryBuffer mbuff = wxBase64Decode(str);
    CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);

    mbuff = wxBase64Decode(encoded0to255);
    CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
}

void Base64TestCase::EncodeDecodePatternA()
{
    unsigned char buff[350];
    generatePatternedData(buff, 350, 24, 5, 3);
    wxString str = wxBase64Encode(buff, 350);
    wxMemoryBuffer mbuff = wxBase64Decode(str);
    CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
}

void Base64TestCase::EncodeDecodePatternB()
{
    unsigned char buff[350];
    generatePatternedData(buff, 350, 0, 1, 1, 0xAA);
    wxString str = wxBase64Encode(buff, 350);
    wxMemoryBuffer mbuff = wxBase64Decode(str);
    CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
}

void Base64TestCase::EncodeDecodePatternC()
{
    unsigned char buff[11];
    generatePatternedData(buff, 11, 1, 0, 2);
    wxString str = wxBase64Encode(buff, 11);
    wxMemoryBuffer mbuff = wxBase64Decode(str);
    CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
}

void Base64TestCase::EncodeDecodeRandom()
{
    size_t size = rand() * 3000 / RAND_MAX + 11;
    unsigned char *buff = new unsigned char[size];
    generateRandomData(buff, size);
    wxString str = wxBase64Encode(buff, size);
    wxMemoryBuffer mbuff = wxBase64Decode(str);
    CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);

    generateGibberish(buff, size);
    char *buff2 = new char[size];
    size_t realsize = size;
    CPPUNIT_ASSERT(wxBase64Decode(buff2, realsize, (char *)buff, size));
    CPPUNIT_ASSERT(wxBase64Encode(buff2, size, buff2, realsize));
}

void Base64TestCase::DecodeInvalid()
{
    size_t rc, posErr;
    rc = wxBase64Decode(NULL, 0, "one two!", wxNO_LEN,
                        wxBase64DecodeMode_Strict, &posErr);
    CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, rc);
    CPPUNIT_ASSERT_EQUAL( 3, posErr );

    rc = wxBase64Decode(NULL, 0, "one two!", wxNO_LEN,
                        wxBase64DecodeMode_SkipWS, &posErr);
    CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, rc);
    CPPUNIT_ASSERT_EQUAL( 7, posErr );

    rc = wxBase64Decode(NULL, 0, "? QQ==", wxNO_LEN,
                        wxBase64DecodeMode_SkipWS, &posErr);
    CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, rc);
    CPPUNIT_ASSERT_EQUAL( 0, posErr );

    posErr = (size_t)-1;
    rc = wxBase64Decode(NULL, 0, " QQ==", wxNO_LEN,
                        wxBase64DecodeMode_SkipWS, &posErr);
    CPPUNIT_ASSERT_EQUAL( 1, rc );
    CPPUNIT_ASSERT_EQUAL( -1, posErr );

    rc = wxBase64Decode(NULL, 0, "? QQ==", wxNO_LEN,
                        wxBase64DecodeMode_Relaxed, &posErr);
    CPPUNIT_ASSERT_EQUAL( 1, rc );
    CPPUNIT_ASSERT_EQUAL( -1, posErr );

    CPPUNIT_ASSERT( !wxBase64Decode("wxGetApp()").GetDataLen() );
}

#endif // wxUSE_BASE64
Commit	Line	Data
4db03d26 VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/base64/base64.cpp
	3	// Purpose: wxBase64Encode/Decode unit test
	4	// Author: Charles Reimers
	5	// Created: 2007-06-22
	6	// RCS-ID: $Id$
	7	///////////////////////////////////////////////////////////////////////////////
	8
	9	// ----------------------------------------------------------------------------
	10	// headers
	11	// ----------------------------------------------------------------------------
	12
	13	#include "testprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#ifndef WX_PRECOMP
	20	#include "wx/wx.h"
	21	#endif // WX_PRECOMP
	22
	23	#if wxUSE_BASE64
	24
	25	#include "wx/base64.h"
	26
	27	static const char encoded0to255[] =
	28	"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIj"
	29	"JCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZH"
	30	"SElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWpr"
	31	"bG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6P"
	32	"kJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKz"
	33	"tLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX"
	34	"2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7"
	35	"/P3+/w==";
	36
	37	static void
	38	generatePatternedData(void* buff, size_t len, unsigned char startVal,
	39	unsigned char addVal, unsigned char multVal = 1,
	40	unsigned char xorMask = 0, unsigned char andMask = 255)
	41	{
	42	unsigned char cbuff = (unsigned char )buff;
	43	unsigned char curval = startVal;
	44	while(len--)
	45	{
	46	*(cbuff++) = curval;
	47	curval = (((curval + addVal) * multVal) ^ xorMask) & andMask;
	48	}
	49	}
	50
	51	static void generateRandomData(void* buff, size_t len)
	52	{
	53	unsigned char cbuff = (unsigned char )buff;
	54	while(len--)
	55	{
	56	(cbuff++) = (unsigned char)(((rand() 255) / RAND_MAX));
	57	}
	58	}
	59
	60	static void generateGibberish(void* buff, size_t len)
	61	{
d2001a56	62	static const unsigned char cb64[] =
4db03d26 VZ	63	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	64
	65	unsigned char cbuff = (unsigned char )buff;
	66	while(len--)
	67	{
	68	(cbuff++) = cb64[((rand() 64) / RAND_MAX)];
	69	}
	70	}
	71
	72	// --------------------------------------------------------------------------
	73	// test class
	74	// --------------------------------------------------------------------------
	75
	76	class Base64TestCase : public CppUnit::TestCase
	77	{
	78	public:
	79	Base64TestCase() { }
	80
	81	private:
	82	CPPUNIT_TEST_SUITE( Base64TestCase );
	83	CPPUNIT_TEST( EncodeDecodeEmpty );
	84	CPPUNIT_TEST( EncodeDecodeA );
	85	CPPUNIT_TEST( EncodeDecodeAB );
	86	CPPUNIT_TEST( EncodeDecodeABC );
	87	CPPUNIT_TEST( EncodeDecodeABCD );
	88	CPPUNIT_TEST( EncodeDecode0to255 );
	89	CPPUNIT_TEST( EncodeDecodePatternA );
	90	CPPUNIT_TEST( EncodeDecodePatternB );
	91	CPPUNIT_TEST( EncodeDecodePatternC );
	92	CPPUNIT_TEST( EncodeDecodeRandom );
7bac0684	93	CPPUNIT_TEST( DecodeInvalid );
4db03d26 VZ	94	CPPUNIT_TEST_SUITE_END();
	95
	96	void EncodeDecodeEmpty();
	97	void EncodeDecodeA();
	98	void EncodeDecodeAB();
	99	void EncodeDecodeABC();
	100	void EncodeDecodeABCD();
	101	void EncodeDecode0to255();
	102	void EncodeDecodePatternA();
	103	void EncodeDecodePatternB();
	104	void EncodeDecodePatternC();
	105	void EncodeDecodeRandom();
7bac0684	106	void DecodeInvalid();
4db03d26 VZ	107
	108	DECLARE_NO_COPY_CLASS(Base64TestCase)
	109	};
	110
	111	// register in the unnamed registry so that these tests are run by default
	112	CPPUNIT_TEST_SUITE_REGISTRATION( Base64TestCase );
	113
e3778b4d	114	// also include in its own registry so that these tests can be run alone
4db03d26 VZ	115	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( Base64TestCase, "Base64TestCase" );
	116
	117	void Base64TestCase::EncodeDecodeEmpty()
	118	{
	119	char shouldBeEmpty[10];
	120	shouldBeEmpty[0] = '\0';
	121	size_t len = 10;
	122
	123	CPPUNIT_ASSERT(wxBase64Encode(shouldBeEmpty, len, "", 0) != wxCONV_FAILED);
	124	CPPUNIT_ASSERT_EQUAL('\0', shouldBeEmpty[0]);
	125
	126	CPPUNIT_ASSERT(wxBase64Decode(shouldBeEmpty, len, "") != wxCONV_FAILED);
	127	CPPUNIT_ASSERT_EQUAL('\0', shouldBeEmpty[0]);
	128
	129	wxMemoryBuffer bufmt;
ee8c79c1 VZ	130	wxString resultEmpty = wxBase64Encode(bufmt);
ee8c79c1 VZ	131	CPPUNIT_ASSERT(resultEmpty.empty());
4db03d26	132
ee8c79c1	133	bufmt = wxBase64Decode(resultEmpty);
1de532f5	134	CPPUNIT_ASSERT_EQUAL(0, bufmt.GetDataLen());
4db03d26 VZ	135	}
	136
	137	void Base64TestCase::EncodeDecodeA()
	138	{
	139	const wxString str = wxBase64Encode("A", 1);
	140	CPPUNIT_ASSERT_EQUAL(wxString("QQ=="), str);
	141
	142	wxMemoryBuffer buf = wxBase64Decode(str);
1de532f5	143	CPPUNIT_ASSERT_EQUAL(1, buf.GetDataLen());
4db03d26	144	CPPUNIT_ASSERT_EQUAL('A', (char )buf.GetData());
07890fbe VZ	145
	146	char cbuf[10];
	147	memset(cbuf, (char)-1, sizeof(cbuf));
	148	CPPUNIT_ASSERT_EQUAL( 1, wxBase64Decode(cbuf, 1, str) );
	149	CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
	150	CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[1] );
	151	CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[2] );
4db03d26 VZ	152	}
	153
	154	void Base64TestCase::EncodeDecodeAB()
	155	{
	156	const wxString str = wxBase64Encode("AB", 2);
	157	CPPUNIT_ASSERT_EQUAL(wxString("QUI="), str);
	158
	159	wxMemoryBuffer buf = wxBase64Decode(str);
1de532f5	160	CPPUNIT_ASSERT_EQUAL(2, buf.GetDataLen());
4db03d26 VZ	161	CPPUNIT_ASSERT_EQUAL('A', buf[0]);
4db03d26 VZ	162	CPPUNIT_ASSERT_EQUAL('B', buf[1]);
07890fbe VZ	163
	164	char cbuf[10];
	165	memset(cbuf, (char)-1, sizeof(cbuf));
	166	CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, wxBase64Decode(cbuf, 1, str) );
	167	CPPUNIT_ASSERT_EQUAL( 2, wxBase64Decode(cbuf, 2, str) );
	168	CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
	169	CPPUNIT_ASSERT_EQUAL( 'B', cbuf[1] );
	170	CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[2] );
	171	CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[3] );
4db03d26 VZ	172	}
	173
	174	void Base64TestCase::EncodeDecodeABC()
	175	{
	176	const wxString str = wxBase64Encode("ABC", 3);
	177	CPPUNIT_ASSERT_EQUAL(wxString("QUJD"), str);
	178
	179	wxMemoryBuffer buf = wxBase64Decode(str);
1de532f5	180	CPPUNIT_ASSERT_EQUAL(3, buf.GetDataLen());
4db03d26 VZ	181	CPPUNIT_ASSERT_EQUAL('A', buf[0]);
	182	CPPUNIT_ASSERT_EQUAL('B', buf[1]);
	183	CPPUNIT_ASSERT_EQUAL('C', buf[2]);
07890fbe VZ	184
	185	char cbuf[10];
	186	memset(cbuf, (char)-1, sizeof(cbuf));
	187	CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, wxBase64Decode(cbuf, 2, str) );
	188	CPPUNIT_ASSERT_EQUAL( 3, wxBase64Decode(cbuf, 3, str) );
	189	CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
	190	CPPUNIT_ASSERT_EQUAL( 'B', cbuf[1] );
	191	CPPUNIT_ASSERT_EQUAL( 'C', cbuf[2] );
	192	CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[3] );
	193	CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[4] );
4db03d26 VZ	194	}
	195
	196	void Base64TestCase::EncodeDecodeABCD()
	197	{
	198	const wxString str = wxBase64Encode("ABCD", 4);
	199	CPPUNIT_ASSERT_EQUAL(wxString("QUJDRA=="), str);
	200
	201	wxMemoryBuffer buf = wxBase64Decode(str);
1de532f5	202	CPPUNIT_ASSERT_EQUAL(4, buf.GetDataLen());
4db03d26 VZ	203	CPPUNIT_ASSERT_EQUAL('A', buf[0]);
	204	CPPUNIT_ASSERT_EQUAL('B', buf[1]);
	205	CPPUNIT_ASSERT_EQUAL('C', buf[2]);
	206	CPPUNIT_ASSERT_EQUAL('D', buf[3]);
07890fbe VZ	207
	208	char cbuf[10];
	209	memset(cbuf, (char)-1, sizeof(cbuf));
	210	CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, wxBase64Decode(cbuf, 3, str) );
	211	CPPUNIT_ASSERT_EQUAL( 4, wxBase64Decode(cbuf, 4, str) );
	212	CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
	213	CPPUNIT_ASSERT_EQUAL( 'B', cbuf[1] );
	214	CPPUNIT_ASSERT_EQUAL( 'C', cbuf[2] );
	215	CPPUNIT_ASSERT_EQUAL( 'D', cbuf[3] );
	216	CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[4] );
	217	CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[5] );
4db03d26 VZ	218	}
	219
	220	void Base64TestCase::EncodeDecode0to255()
	221	{
	222	unsigned char buff[256];
	223	generatePatternedData(buff, 256, 0, 1);
	224	wxString str = wxBase64Encode(buff, 256);
	225	wxMemoryBuffer mbuff = wxBase64Decode(str);
	226	CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
	227
	228	mbuff = wxBase64Decode(encoded0to255);
	229	CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
	230	}
	231
	232	void Base64TestCase::EncodeDecodePatternA()
	233	{
	234	unsigned char buff[350];
	235	generatePatternedData(buff, 350, 24, 5, 3);
	236	wxString str = wxBase64Encode(buff, 350);
	237	wxMemoryBuffer mbuff = wxBase64Decode(str);
	238	CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
	239	}
	240
	241	void Base64TestCase::EncodeDecodePatternB()
	242	{
	243	unsigned char buff[350];
	244	generatePatternedData(buff, 350, 0, 1, 1, 0xAA);
	245	wxString str = wxBase64Encode(buff, 350);
	246	wxMemoryBuffer mbuff = wxBase64Decode(str);
	247	CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
	248	}
	249
	250	void Base64TestCase::EncodeDecodePatternC()
	251	{
	252	unsigned char buff[11];
	253	generatePatternedData(buff, 11, 1, 0, 2);
	254	wxString str = wxBase64Encode(buff, 11);
	255	wxMemoryBuffer mbuff = wxBase64Decode(str);
	256	CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
	257	}
	258
	259	void Base64TestCase::EncodeDecodeRandom()
	260	{
	261	size_t size = rand() * 3000 / RAND_MAX + 11;
	262	unsigned char *buff = new unsigned char[size];
	263	generateRandomData(buff, size);
	264	wxString str = wxBase64Encode(buff, size);
	265	wxMemoryBuffer mbuff = wxBase64Decode(str);
	266	CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
	267
	268	generateGibberish(buff, size);
	269	char *buff2 = new char[size];
	270	size_t realsize = size;
	271	CPPUNIT_ASSERT(wxBase64Decode(buff2, realsize, (char *)buff, size));
	272	CPPUNIT_ASSERT(wxBase64Encode(buff2, size, buff2, realsize));
	273	}
	274
7bac0684 VZ	275	void Base64TestCase::DecodeInvalid()
	276	{
	277	size_t rc, posErr;
	278	rc = wxBase64Decode(NULL, 0, "one two!", wxNO_LEN,
	279	wxBase64DecodeMode_Strict, &posErr);
	280	CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, rc);
1de532f5	281	CPPUNIT_ASSERT_EQUAL( 3, posErr );
7bac0684 VZ	282
	283	rc = wxBase64Decode(NULL, 0, "one two!", wxNO_LEN,
	284	wxBase64DecodeMode_SkipWS, &posErr);
	285	CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, rc);
1de532f5	286	CPPUNIT_ASSERT_EQUAL( 7, posErr );
7bac0684 VZ	287
	288	rc = wxBase64Decode(NULL, 0, "? QQ==", wxNO_LEN,
	289	wxBase64DecodeMode_SkipWS, &posErr);
	290	CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, rc);
1de532f5	291	CPPUNIT_ASSERT_EQUAL( 0, posErr );
7bac0684 VZ	292
	293	posErr = (size_t)-1;
	294	rc = wxBase64Decode(NULL, 0, " QQ==", wxNO_LEN,
	295	wxBase64DecodeMode_SkipWS, &posErr);
1de532f5 VZ	296	CPPUNIT_ASSERT_EQUAL( 1, rc );
1de532f5 VZ	297	CPPUNIT_ASSERT_EQUAL( -1, posErr );
7bac0684 VZ	298
	299	rc = wxBase64Decode(NULL, 0, "? QQ==", wxNO_LEN,
	300	wxBase64DecodeMode_Relaxed, &posErr);
1de532f5 VZ	301	CPPUNIT_ASSERT_EQUAL( 1, rc );
1de532f5 VZ	302	CPPUNIT_ASSERT_EQUAL( -1, posErr );
7bac0684 VZ	303
	304	CPPUNIT_ASSERT( !wxBase64Decode("wxGetApp()").GetDataLen() );
	305	}
	306
4db03d26	307	#endif // wxUSE_BASE64