TestBase64.cc

Veure la documentació d'aquest fitxer.

/*
 * Copyright (c) 2012 Toni Corvera
 *
 * This file is part of TFCWeb.
 *
 * TFCWeb 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.
 *
 * TFCWeb 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 TFCWeb. If not, see <http://www.gnu.org/licenses/>.
 */

#include <fstream>
#include <string>

#include <Base64.h>
#include <portabilitat.h>

#include "comu.h"

using namespace std;
using namespace tfc;
using namespace tfc::Base64;


#if 0
// Filtrat amb Boost.Iostreams. Aquest codi no és necessari però l'he escrit per
// aprofundir en l'ús de la biblioteca abans d'escriure filtres com Chunked (Transformacions.h)

#include <cstdio> // EOF
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/operations.hpp>
#include <boost/iostreams/invert.hpp>
#include <boost/iostreams/device/file_descriptor.hpp>
#include <boost/iostreams/filtering_stream.hpp>

namespace tfc {

namespace Base64 {

namespace io = boost::iostreams;

class CodificadorBase64 : public io::multichar_output_filter {
public:
    template<typename TDesti>
    streamsize write(TDesti& dest, const char * buf, streamsize mida) {
        const string codificat = codifica(string(buf, mida));
        return dest.write(codificat.c_str(), codificat.length());
    }

};

}} // ns

#endif

namespace tfc { namespace Fixtures {

// generat amb bash:
// echo -n '{ '; for i in $(seq 1 40); do printf '0x%x, ' $(($RANDOM % 256)); done ; echo '0x00 }'
const unsigned char test_base64_cadena_binaria[] = { 0x2d, 0xe1, 0xb0, 0xa9, 0x28, 0x8c, 0x5a,
        0x21, 0xd4, 0xb5, 0x84, 0x67, 0x7f, 0x96, 0x18, 0xa, 0x0, 0x15, 0x3f, 0xcd,
        0x3f, 0x7f, 0x58, 0x27, 0x96, 0xd2, 0x8d, 0x63, 0xab, 0x17, 0x4, 0x25, 0xec,
        0x9c, 0xeb, 0x5, 0x5e, 0xa3, 0xf6, 0xa8, 0x00 };

struct FxtBase64 {
    FxtBase64()
        : text_llarg("Lorem ipsum dolor sit amet, consectetur adipiscing elit. "
                     "In in urna ligula. Nunc condimentum pretium urna eu pharetra. "
                     "Lorem ipsum dolor sit amet, consectetur adipiscing elit. "
                     "Donec auctor felis sed ipsum tristique fermentum. "
                     "Vivamus id luctus justo. Phasellus enim neque, ultricies sed "
                     "varius at, vehicula aliquam elit. Sed molestie condimentum "
                     "erat, at commodo tortor consectetur eu. Donec lacinia lorem "
                     "vel arcu dictum commodo eget at libero. Cras rutrum quam "
                     "quis tortor tincidunt at convallis turpis euismod.")
    {
        const char * principi = reinterpret_cast<const char *>(test_base64_cadena_binaria);
        const char * final = principi + 40;
        cadena_binaria.assign(principi, final);
    }
    string text_llarg;
    string cadena_binaria;
};

} // ns Fixtures
} // ns tfc

BOOST_FIXTURE_TEST_SUITE( Base64_TestSuite, Fixtures::FxtBase64 )

BOOST_AUTO_TEST_CASE( sense_padding )
{
    BOOST_CHECK_EQUAL( codifica("Sense pad"), "U2Vuc2UgcGFk" );
    BOOST_CHECK_EQUAL( descodifica("U2Vuc2UgcGFk"), "Sense pad" );
}

BOOST_AUTO_TEST_CASE( padding_1_caracter )
{
    BOOST_CHECK_EQUAL( codifica("PAD=1"), "UEFEPTE=" );
    BOOST_CHECK_EQUAL( descodifica("UEFEPTE="), "PAD=1" );
}

BOOST_AUTO_TEST_CASE( padding_2_caracters )
{
    BOOST_CHECK_EQUAL( codifica("padding: 2"), "cGFkZGluZzogMg==" );
    BOOST_CHECK_EQUAL( descodifica("cGFkZGluZzogMg=="), "padding: 2" );
    BOOST_CHECK_EQUAL( codifica("abcdefghijkml"), "YWJjZGVmZ2hpamttbA==" );
}

BOOST_AUTO_TEST_CASE( simetria )
{
    BOOST_CHECK_EQUAL( text_llarg, descodifica(codifica(text_llarg)) );
    BOOST_CHECK_EQUAL( cadena_binaria, descodifica(codifica(cadena_binaria)) );
    /*
    ifstream ifs("/dev/urandom");
    char buf[1024];
    ifs.read(buf, 1024);
    ifs.close();
    const string sx(buf, 1024);
    BOOST_CHECK_EQUAL( sx, descodifica(codifica(sx)) );
    */
}

#if 0
BOOST_AUTO_TEST_CASE( boost_iostreams )
{
    namespace io = boost::iostreams;
    string nom;
    std::shared_ptr<std::ofstream> tmp = portabilitat::fitxer_temporal("base64", nom);
    cerr << "Fitxer temporal: " << nom << endl;
    tmp->close();
    unlink(nom.c_str());

//    io::basic_file_sink(nom.c_str());
    io::filtering_ostream out;
    out.push(CodificadorBase64());
}
#endif

BOOST_AUTO_TEST_SUITE_END()

// vim:set ts=4 et ai: //