[libi2ncommon] / test / stringfunc.cpp

/***************************************************************************
 *   Copyright (C) 2006 by Intra2net AG                                    *
 *   info@intra2net.com                                                    *
 *                                                                         *
 ***************************************************************************/

// #include <iostream>
#include <string>
// #include <sstream>
// #include <stdexcept>

#define BOOST_TEST_DYN_LINK
#include <boost/test/unit_test.hpp>

#include <stringfunc.hxx>
#include <containerfunc.hpp>

using namespace std;
using namespace I2n;

typedef std::list< std::string > StringList;

BOOST_AUTO_TEST_SUITE(stringfunc)

BOOST_AUTO_TEST_CASE(smart_html_entites1)
{
    string output = smart_html_entities("Test");

    BOOST_CHECK_EQUAL(string("Test"), output);
}

BOOST_AUTO_TEST_CASE(smart_html_entites2)
{
    string output = smart_html_entities("Täst");

    BOOST_CHECK_EQUAL(string("T&auml;st"), output);
}

BOOST_AUTO_TEST_CASE(smart_html_entites3)
{
    string output = smart_html_entities("<>");

    BOOST_CHECK_EQUAL(string("<>"), output);
}

BOOST_AUTO_TEST_CASE(smart_html_entites4)
{
    string output = smart_html_entities("<ümlaut>");

    BOOST_CHECK_EQUAL(string("<ümlaut>"), output);
}

BOOST_AUTO_TEST_CASE(smart_html_entites5)
{
    string output = smart_html_entities("Test<ümlaut>Blä");

    BOOST_CHECK_EQUAL(string("Test<ümlaut>Bl&auml;"), output);
}

BOOST_AUTO_TEST_CASE(smart_html_entites6)
{
    string output = smart_html_entities("System > Einstellungen");

    BOOST_CHECK_EQUAL(string("System &gt; Einstellungen"), output);
}

BOOST_AUTO_TEST_CASE(smart_html_entites7)
{
    string output = smart_html_entities("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">\"System > Einstellungen\"</a>. Oder etwa nicht?");

    BOOST_CHECK_EQUAL(string("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">&quot;System &gt; Einstellungen&quot;</a>. Oder etwa nicht?"), output);
}

BOOST_AUTO_TEST_CASE(strip_html_tags1)
{
    string output = strip_html_tags("Was für ein schöner Tag, finden Sie nicht?");

    BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output);
}

BOOST_AUTO_TEST_CASE(strip_html_tags2)
{
    string output = strip_html_tags("Was für ein <a href=\"wikipedia\" target=\"new\">schöner Tag</a>, finden Sie nicht?");

    BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output);
}


BOOST_AUTO_TEST_CASE(html_entities1)
{
    string output = html_entities("\xC3\xA4\xC3\xB6\xC3\xBC");
    BOOST_CHECK_EQUAL(string("&auml;&ouml;&uuml;"), output);
}

BOOST_AUTO_TEST_CASE(html_entities2)
{
    string output = html_entities("\xC3\xA5 \xC3\xB5 \xC3\xBF");
    BOOST_CHECK_EQUAL(string("&#229; &#245; &#255;"), output);
}

BOOST_AUTO_TEST_CASE(html_entities3)
{
    string output = html_entities("\xC4\x8E \xE0\xBC\xB1 \xE8\x82\x88");
    BOOST_CHECK_EQUAL(string("&#270; &#3889; &#32904;"), output);
}


BOOST_AUTO_TEST_CASE(nice_unit_format1)
{
    const int64_t two_bytes = 2;

    string output = nice_unit_format(two_bytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.00 Bytes"), output);

    output = nice_unit_format(two_bytes);
    BOOST_CHECK_EQUAL(string("2.0 B"), output);
}

BOOST_AUTO_TEST_CASE(nice_unit_format2)
{
    const int64_t two_kilobytes = 2000;

    string output = nice_unit_format(two_kilobytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.00 KBytes"), output);

    output = nice_unit_format(two_kilobytes);
    BOOST_CHECK_EQUAL(string("2.0 KB"), output);

    const int64_t two_and_half_kilobytes = 2500;

    output = nice_unit_format(two_and_half_kilobytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.50 KBytes"), output);

    output = nice_unit_format(two_and_half_kilobytes);
    BOOST_CHECK_EQUAL(string("2.4 KB"), output);
}

BOOST_AUTO_TEST_CASE(nice_unit_format3)
{
    const int64_t two_megabytes = 2000000;

    string output = nice_unit_format(two_megabytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.00 MBytes"), output);

    output = nice_unit_format(two_megabytes);
    BOOST_CHECK_EQUAL(string("1.9 MB"), output);

    const int64_t two_and_half_megabytes = 2500000;

    output = nice_unit_format(two_and_half_megabytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.50 MBytes"), output);

    output = nice_unit_format(two_and_half_megabytes);
    BOOST_CHECK_EQUAL(string("2.4 MB"), output);

}

BOOST_AUTO_TEST_CASE(nice_unit_format4)
{
    const int64_t two_gigabytes = 2000000000LL;

    string output = nice_unit_format(two_gigabytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.00 GBytes"), output);

    output = nice_unit_format(two_gigabytes);
    BOOST_CHECK_EQUAL(string("1.9 GB"), output);

    const int64_t two_and_half_gigabytes = 2500000000LL;

    output = nice_unit_format(two_and_half_gigabytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.50 GBytes"), output);

    output = nice_unit_format(two_and_half_gigabytes);
    BOOST_CHECK_EQUAL(string("2.3 GB"), output);
}

BOOST_AUTO_TEST_CASE(nice_unit_format5)
{
    const int64_t two_terabytes = 2000000000000LL;

    string output = nice_unit_format(two_terabytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.00 TBytes"), output);

    output = nice_unit_format(two_terabytes);
    BOOST_CHECK_EQUAL(string("1.8 TB"), output);

    const int64_t two_and_half_terabytes = 2500000000000LL;

    output = nice_unit_format(two_and_half_terabytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.50 TBytes"), output);

    output = nice_unit_format(two_and_half_terabytes);
    BOOST_CHECK_EQUAL(string("2.3 TB"), output);
}

BOOST_AUTO_TEST_CASE(nice_unit_format6)
{
    const int64_t two_petabytes = 2000000000000000LL;

    string output = nice_unit_format(two_petabytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.00 PBytes"), output);

    output = nice_unit_format(two_petabytes);
    BOOST_CHECK_EQUAL(string("1.8 PB"), output);

    const int64_t two_and_half_petabytes = 2500000000000000LL;

    output = nice_unit_format(two_and_half_petabytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2.50 PBytes"), output);

    output = nice_unit_format(two_and_half_petabytes);
    BOOST_CHECK_EQUAL(string("2.2 PB"), output);
}

BOOST_AUTO_TEST_CASE(nice_unit_format7)
{
    const int64_t two_exabytes = 2000000000000000000LL;

    string output = nice_unit_format(two_exabytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2000.00 PBytes"), output);

    output = nice_unit_format(two_exabytes);
    BOOST_CHECK_EQUAL(string("1776.4 PB"), output);

    const int64_t two_and_half_exabytes = 2500000000000000000LL;

    output = nice_unit_format(two_and_half_exabytes, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("2500.00 PBytes"), output);

    output = nice_unit_format(two_and_half_exabytes);
    BOOST_CHECK_EQUAL(string("2220.4 PB"), output);
}

BOOST_AUTO_TEST_CASE(nice_unit_format8)
{
    const int64_t max_representable_64bits_number = 9223372036854775807LL;

    string output = nice_unit_format(max_representable_64bits_number, LongUnitFormat, UnitBase1000);
    BOOST_CHECK_EQUAL(string("9223.40 PBytes"), output);

    output = nice_unit_format(max_representable_64bits_number);
    BOOST_CHECK_EQUAL(string("8192.0 PB"), output);
}


BOOST_AUTO_TEST_CASE(imaputf7_to_utf8)
{
    string output = utf7imap_to_utf8("Sp&AOQ-m");
    BOOST_CHECK_EQUAL(string("Späm"), output);
}

BOOST_AUTO_TEST_CASE(utf8_to_imaputf7)
{
    string output = utf8_to_utf7imap("Späm");
    BOOST_CHECK_EQUAL(string("Sp&AOQ-m"), output);
}

/*
**
*/

BOOST_AUTO_TEST_CASE(TestTrim)
{
    std::string s("s1");
    trim_mod(s);
    BOOST_CHECK_EQUAL( std::string("s1"), s );

    s="  s2";
    trim_mod(s);
    BOOST_CHECK_EQUAL( std::string("s2"), s );

    s="s3   ";
    trim_mod(s);
    BOOST_CHECK_EQUAL( std::string("s3"), s );

    s="::s4:s4::++--aa";
    trim_mod(s,":+-a");
    BOOST_CHECK_EQUAL( std::string("s4:s4"), s);

    /* non modifying version */

    s= "s1";
    BOOST_CHECK_EQUAL( std::string("s1"), trim(s) );

    s="  s2";
    BOOST_CHECK_EQUAL( std::string("s2"), trim(s) );
    BOOST_CHECK_EQUAL( std::string("  s2"), s );

    s="s3   ";
    BOOST_CHECK_EQUAL( std::string("s3"), trim(s) );
    BOOST_CHECK_EQUAL( std::string("s3   "), s );

    s="::s4:s4::++--aa";
    BOOST_CHECK_EQUAL( std::string("s4:s4"), trim(s,":+-a") );
} // eo TestTrim()


BOOST_AUTO_TEST_CASE(TestChomp)
{
    std::string s("s1");

    chomp_mod(s);
    BOOST_CHECK_EQUAL( std::string("s1"), s );

    s="s2\n";
    chomp_mod(s);
    BOOST_CHECK_EQUAL( std::string("s2"), s );

    s="s3:";
    chomp_mod(s,":");
    BOOST_CHECK_EQUAL( std::string("s3"), s );

    s=":s4::";
    chomp_mod(s,"s:");
    BOOST_CHECK_EQUAL( std::string(":s4:"), s);

    /* non modifiying versions */
    s= "s1";

    BOOST_CHECK_EQUAL( std::string("s1"), chomp(s) );

    s="s2\n";
    BOOST_CHECK_EQUAL( std::string("s2"), chomp(s) );
    BOOST_CHECK_EQUAL( std::string("s2\n"), s);

    s="s3:";
    BOOST_CHECK_EQUAL( std::string("s3"), chomp(s,":") );
    BOOST_CHECK_EQUAL( std::string("s3:"), s);

    s=":s4::";
    BOOST_CHECK_EQUAL( std::string(":s4:"), chomp(s,"s:") );
    BOOST_CHECK_EQUAL( std::string(":s4::"), s);
} // eo TestChomp()


BOOST_AUTO_TEST_CASE(TestSuffixFuncs)
{
    std::string s1("12.cpp");

    BOOST_CHECK_EQUAL( true, has_suffix(s1,".cpp") );
    BOOST_CHECK_EQUAL( true, has_suffix(s1,"pp") );
    BOOST_CHECK_EQUAL( false, has_suffix(s1,"hpp") );
    BOOST_CHECK_EQUAL( false, has_suffix(s1,"cp") );
    BOOST_CHECK_EQUAL( false, has_suffix(s1,"") );

    std::string s1c1= remove_suffix(s1,".cpp");
    BOOST_CHECK_EQUAL( std::string("12"), s1c1 );

    std::string s1c2= remove_suffix(s1,"p");
    BOOST_CHECK_EQUAL( std::string("12.cp"), s1c2 );

    std::string s1c3= remove_suffix(s1,"cp");
    BOOST_CHECK_EQUAL( std::string("12.cpp"), s1c3 );

    std::string s2(".cpp");
    BOOST_CHECK_EQUAL( true, has_suffix(s2,".cpp") );

    std::string s2c1= remove_suffix(s2,".cpp");
    BOOST_CHECK_EQUAL( std::string(""), s2c1 );

} // eo TestSuffixFuncs()


BOOST_AUTO_TEST_CASE(TestPrefixFuncs)
{
    std::string s1("12.cpp");

    BOOST_CHECK_EQUAL( true, has_prefix(s1,"12") );
    BOOST_CHECK_EQUAL( true, has_prefix(s1, "1") );
    BOOST_CHECK_EQUAL( false, has_prefix(s1, "2") );
    BOOST_CHECK_EQUAL( false, has_prefix(s1, "") );

    std::string s1c1= remove_prefix(s1, "12");
    BOOST_CHECK_EQUAL( std::string(".cpp"), s1c1);
} // eo TestPrefixFuncs()


BOOST_AUTO_TEST_CASE(TestLowerUpperFuncs)
{
    std::string u1("CASE CONVERSION TEST..");
    std::string l1("case conversion test..");

    std::string test1(l1);

    to_upper_mod(test1);
    BOOST_CHECK_EQUAL( u1, test1 );

    to_lower_mod(test1);
    BOOST_CHECK_EQUAL( l1, test1 );


    BOOST_CHECK_EQUAL( u1, to_upper(l1) );
    BOOST_CHECK_EQUAL( l1, to_lower(u1) );
} // eo TestLowerUpper


BOOST_AUTO_TEST_CASE(PairSplit1)
{
    StringList str_list;
    get_push_back_filler(str_list)
        ("a=11")("a= 11")("a =11 ")("a =  11 ")("  a    =    11   ")
    ;
    BOOST_CHECK_EQUAL( 5u, str_list.size() );
    for(StringList::iterator it= str_list.begin();
        it != str_list.end();
        ++it)
    {
        std::string key, value;
        bool res= pair_split( *it, key, value);

        BOOST_CHECK_EQUAL( true , res );
        BOOST_CHECK_EQUAL( std::string("a"), key );
        BOOST_CHECK_EQUAL( std::string("11"), value );
    }

    std::string key, value;
    bool res;

    res= pair_split(" 1 : 2 ", key, value, ':');
    BOOST_CHECK_EQUAL( true, res );
    BOOST_CHECK_EQUAL( std::string("1"), key);
    BOOST_CHECK_EQUAL( std::string("2"), value);
} // eo PairSplit1


BOOST_AUTO_TEST_CASE(SplitString1)
{
    std::string block(
        "Zeile 1\n"
        "++Zeile-2--\n"
        "Zeile 3\n"
        "\n"
        "Zeile 5\n"
    );

    StringList list1;

    split_string(block, list1, "\n");
    // since the blocks ends with \n we should have 6 lines (the last one empty):
    BOOST_CHECK_EQUAL( 6u, list1.size() );
    BOOST_CHECK_EQUAL( std::string(), list1.back() );
    BOOST_CHECK_EQUAL( std::string("Zeile 1"), list1.front() );

    StringList list2;

    split_string(block, list2, "\n", true);

    // now we omitted empty lines, now we should have only 4 lines left:
    BOOST_CHECK_EQUAL( 4u, list2.size() );
    BOOST_CHECK_EQUAL( std::string("Zeile 5"), list2.back() );
    BOOST_CHECK_EQUAL( std::string("Zeile 1"), list2.front() );

    list2= split_string(block, "\n", true, "+-");

    // again, we omitted empty lines, but also trimmed away leading and trailing "+" and "-"
    BOOST_CHECK_EQUAL( 4u, list2.size() );
    BOOST_CHECK_EQUAL( std::string("Zeile 5"), list2.back() );
    BOOST_CHECK_EQUAL( std::string("Zeile 1"), list2.front() );
    BOOST_CHECK_EQUAL( std::string("Zeile-2"), *(++list2.begin()) );
} // eo SplitString1


BOOST_AUTO_TEST_CASE(SplitString2)
{
    std::string line("172.16.0.0/16 dev eth0  scope link  src 172.16.1.111");

    StringList list1;

    split_string(line, list1, " ", true, Whitespaces);

    BOOST_CHECK_EQUAL( 7u, list1.size() );

} // eo SplitString2


BOOST_AUTO_TEST_CASE(SplitStringEmpty)
{
    std::string line("");

    StringList list1;

    split_string(line, list1, " ", true, Whitespaces);

    BOOST_CHECK_EQUAL( 0u, list1.size() );
} // eo SplitStringEmpty


BOOST_AUTO_TEST_CASE(SplitStringDelimiterOnly)
{
    std::string line(" ");

    StringList list1;

    split_string(line, list1, " ", true, Whitespaces);

    BOOST_CHECK_EQUAL( 0u, list1.size() );
} // eo SplitStringDelimiterOnly


BOOST_AUTO_TEST_CASE(JoinString1)
{
    std::list< std::string > parts;
    get_push_back_filler(parts)("1")("2")("drei");

    std::string joined_string= join_string(parts,"/");
    // we should have slashes between the strings:
    BOOST_CHECK_EQUAL( std::string("1/2/drei") , joined_string );

    parts.push_back( std::string() );
    joined_string= join_string(parts,"/");
    // now we should have an additional trailing slash:
    BOOST_CHECK_EQUAL( std::string("1/2/drei/") , joined_string );

    parts.push_front( std::string() );
    joined_string= join_string(parts,"/");
    // now we should have an additional leading slash:
    BOOST_CHECK_EQUAL( std::string("/1/2/drei/") , joined_string );

} // eo JoinString1


BOOST_AUTO_TEST_CASE(ConversionStringInt)
{
    std::string s1("24");
    std::string s1x("25x");
    int i1=0;
    bool res= false;

    i1= string_to<int>(s1);
    BOOST_CHECK_EQUAL( 24, i1 );
    i1= string_to<int>(s1x);
    BOOST_CHECK_EQUAL( 25, i1 );

    res= string_to<int>(s1,i1);
    BOOST_CHECK_EQUAL( true, res );
    BOOST_CHECK_EQUAL( 24, i1 );

    res= string_to<int>(s1x,i1);
    BOOST_CHECK_EQUAL( false, res );

    std::string ss1= to_string( 24 );
    BOOST_CHECK_EQUAL( std::string("24"), ss1);

} // eo ConversionStringInt()


BOOST_AUTO_TEST_CASE(HexConversion)
{
    std::string hex1("49324E");
    std::string bin1("I2N");

    BOOST_CHECK_EQUAL( hex1, convert_binary_to_hex(bin1,true) );
    BOOST_CHECK_EQUAL( bin1, convert_hex_to_binary(hex1) );
    BOOST_CHECK_EQUAL( to_lower(hex1), convert_binary_to_hex(bin1) );

    std::string hex2("0001");
    std::string hex2a("00 01");
    std::string hex2b("00:01");
    std::string bin2("\0\1",2);

    BOOST_CHECK_EQUAL( hex2, convert_binary_to_hex(bin2) );
    BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2) );
    BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2a) );
    BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2b) );

    BOOST_REQUIRE_THROW( convert_hex_to_binary("01 kein hex"), std::runtime_error);
} // eo HexConversion()

BOOST_AUTO_TEST_SUITE_END()
Commit	Line	Data
118e216e TJ	1	/***************************************************************************
	2	* Copyright (C) 2006 by Intra2net AG *
	3	* info@intra2net.com *
	4	* *
	5	***************************************************************************/
	6
	7	// #include <iostream>
	8	#include <string>
	9	// #include <sstream>
	10	// #include <stdexcept>
	11
9fe0853b TJ	12	#define BOOST_TEST_DYN_LINK
9fe0853b TJ	13	#include <boost/test/unit_test.hpp>
118e216e TJ	14
118e216e TJ	15	#include <stringfunc.hxx>
57e78ccd	16	#include <containerfunc.hpp>
118e216e TJ	17
118e216e TJ	18	using namespace std;
57e78ccd	19	using namespace I2n;
118e216e	20
9fe0853b TJ	21	typedef std::list< std::string > StringList;
	22
	23	BOOST_AUTO_TEST_SUITE(stringfunc)
	24
	25	BOOST_AUTO_TEST_CASE(smart_html_entites1)
	26	{
	27	string output = smart_html_entities("Test");
	28
	29	BOOST_CHECK_EQUAL(string("Test"), output);
	30	}
	31
	32	BOOST_AUTO_TEST_CASE(smart_html_entites2)
	33	{
	34	string output = smart_html_entities("Täst");
	35
	36	BOOST_CHECK_EQUAL(string("Täst"), output);
	37	}
	38
	39	BOOST_AUTO_TEST_CASE(smart_html_entites3)
	40	{
	41	string output = smart_html_entities("<>");
	42
	43	BOOST_CHECK_EQUAL(string("<>"), output);
	44	}
	45
	46	BOOST_AUTO_TEST_CASE(smart_html_entites4)
	47	{
	48	string output = smart_html_entities("<ümlaut>");
	49
	50	BOOST_CHECK_EQUAL(string("<ümlaut>"), output);
	51	}
	52
	53	BOOST_AUTO_TEST_CASE(smart_html_entites5)
	54	{
	55	string output = smart_html_entities("Test<ümlaut>Blä");
	56
	57	BOOST_CHECK_EQUAL(string("Test<ümlaut>Blä"), output);
	58	}
	59
	60	BOOST_AUTO_TEST_CASE(smart_html_entites6)
	61	{
	62	string output = smart_html_entities("System > Einstellungen");
	63
	64	BOOST_CHECK_EQUAL(string("System > Einstellungen"), output);
	65	}
	66
	67	BOOST_AUTO_TEST_CASE(smart_html_entites7)
	68	{
	69	string output = smart_html_entities("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">\"System > Einstellungen\"</a>. Oder etwa nicht?");
	70
	71	BOOST_CHECK_EQUAL(string("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">"System > Einstellungen"</a>. Oder etwa nicht?"), output);
	72	}
	73
	74	BOOST_AUTO_TEST_CASE(strip_html_tags1)
	75	{
	76	string output = strip_html_tags("Was für ein schöner Tag, finden Sie nicht?");
	77
	78	BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output);
	79	}
	80
	81	BOOST_AUTO_TEST_CASE(strip_html_tags2)
	82	{
	83	string output = strip_html_tags("Was für ein <a href=\"wikipedia\" target=\"new\">schöner Tag</a>, finden Sie nicht?");
	84
85	BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output);
86	}
87
8b06a5c9 GMF	88
8b06a5c9 GMF	89
9fe0853b TJ	90	BOOST_AUTO_TEST_CASE(html_entities1)
	91	{
	92	string output = html_entities("\xC3\xA4\xC3\xB6\xC3\xBC");
	93	BOOST_CHECK_EQUAL(string("äöü"), output);
	94	}
	95
	96	BOOST_AUTO_TEST_CASE(html_entities2)
	97	{
	98	string output = html_entities("\xC3\xA5 \xC3\xB5 \xC3\xBF");
	99	BOOST_CHECK_EQUAL(string("å õ ÿ"), output);
	100	}
	101
	102	BOOST_AUTO_TEST_CASE(html_entities3)
	103	{
	104	string output = html_entities("\xC4\x8E \xE0\xBC\xB1 \xE8\x82\x88");
	105	BOOST_CHECK_EQUAL(string("Ď ༱ 肈"), output);
	106	}
	107
8b06a5c9 GMF	108
8b06a5c9 GMF	109
388626dc GMF	110	BOOST_AUTO_TEST_CASE(nice_unit_format1)
	111	{
	112	const int64_t two_bytes = 2;
8b06a5c9	113
70fc0674	114	string output = nice_unit_format(two_bytes, LongUnitFormat, UnitBase1000);
388626dc	115	BOOST_CHECK_EQUAL(string("2.00 Bytes"), output);
8b06a5c9	116
4388cc08	117	output = nice_unit_format(two_bytes);
8b06a5c9	118	BOOST_CHECK_EQUAL(string("2.0 B"), output);
388626dc GMF	119	}
	120
	121	BOOST_AUTO_TEST_CASE(nice_unit_format2)
	122	{
	123	const int64_t two_kilobytes = 2000;
8b06a5c9	124
70fc0674	125	string output = nice_unit_format(two_kilobytes, LongUnitFormat, UnitBase1000);
388626dc GMF	126	BOOST_CHECK_EQUAL(string("2.00 KBytes"), output);
388626dc GMF	127
4388cc08	128	output = nice_unit_format(two_kilobytes);
8b06a5c9 GMF	129	BOOST_CHECK_EQUAL(string("2.0 KB"), output);
8b06a5c9 GMF	130
388626dc	131	const int64_t two_and_half_kilobytes = 2500;
8b06a5c9	132
70fc0674	133	output = nice_unit_format(two_and_half_kilobytes, LongUnitFormat, UnitBase1000);
388626dc	134	BOOST_CHECK_EQUAL(string("2.50 KBytes"), output);
8b06a5c9	135
4388cc08	136	output = nice_unit_format(two_and_half_kilobytes);
8b06a5c9	137	BOOST_CHECK_EQUAL(string("2.4 KB"), output);
388626dc GMF	138	}
	139
	140	BOOST_AUTO_TEST_CASE(nice_unit_format3)
	141	{
	142	const int64_t two_megabytes = 2000000;
8b06a5c9	143
70fc0674	144	string output = nice_unit_format(two_megabytes, LongUnitFormat, UnitBase1000);
388626dc GMF	145	BOOST_CHECK_EQUAL(string("2.00 MBytes"), output);
388626dc GMF	146
4388cc08	147	output = nice_unit_format(two_megabytes);
8b06a5c9 GMF	148	BOOST_CHECK_EQUAL(string("1.9 MB"), output);
8b06a5c9 GMF	149
388626dc	150	const int64_t two_and_half_megabytes = 2500000;
8b06a5c9	151
70fc0674	152	output = nice_unit_format(two_and_half_megabytes, LongUnitFormat, UnitBase1000);
388626dc	153	BOOST_CHECK_EQUAL(string("2.50 MBytes"), output);
8b06a5c9	154
4388cc08	155	output = nice_unit_format(two_and_half_megabytes);
8b06a5c9 GMF	156	BOOST_CHECK_EQUAL(string("2.4 MB"), output);
8b06a5c9 GMF	157
388626dc GMF	158	}
	159
	160	BOOST_AUTO_TEST_CASE(nice_unit_format4)
	161	{
	162	const int64_t two_gigabytes = 2000000000LL;
8b06a5c9	163
70fc0674	164	string output = nice_unit_format(two_gigabytes, LongUnitFormat, UnitBase1000);
388626dc GMF	165	BOOST_CHECK_EQUAL(string("2.00 GBytes"), output);
388626dc GMF	166
4388cc08	167	output = nice_unit_format(two_gigabytes);
8b06a5c9 GMF	168	BOOST_CHECK_EQUAL(string("1.9 GB"), output);
8b06a5c9 GMF	169
388626dc	170	const int64_t two_and_half_gigabytes = 2500000000LL;
8b06a5c9	171
70fc0674	172	output = nice_unit_format(two_and_half_gigabytes, LongUnitFormat, UnitBase1000);
388626dc	173	BOOST_CHECK_EQUAL(string("2.50 GBytes"), output);
8b06a5c9	174
4388cc08	175	output = nice_unit_format(two_and_half_gigabytes);
8b06a5c9	176	BOOST_CHECK_EQUAL(string("2.3 GB"), output);
388626dc GMF	177	}
	178
	179	BOOST_AUTO_TEST_CASE(nice_unit_format5)
	180	{
	181	const int64_t two_terabytes = 2000000000000LL;
8b06a5c9	182
70fc0674	183	string output = nice_unit_format(two_terabytes, LongUnitFormat, UnitBase1000);
388626dc GMF	184	BOOST_CHECK_EQUAL(string("2.00 TBytes"), output);
388626dc GMF	185
4388cc08	186	output = nice_unit_format(two_terabytes);
8b06a5c9 GMF	187	BOOST_CHECK_EQUAL(string("1.8 TB"), output);
8b06a5c9 GMF	188
388626dc	189	const int64_t two_and_half_terabytes = 2500000000000LL;
8b06a5c9	190
70fc0674	191	output = nice_unit_format(two_and_half_terabytes, LongUnitFormat, UnitBase1000);
388626dc	192	BOOST_CHECK_EQUAL(string("2.50 TBytes"), output);
8b06a5c9	193
4388cc08	194	output = nice_unit_format(two_and_half_terabytes);
8b06a5c9	195	BOOST_CHECK_EQUAL(string("2.3 TB"), output);
388626dc GMF	196	}
	197
	198	BOOST_AUTO_TEST_CASE(nice_unit_format6)
	199	{
	200	const int64_t two_petabytes = 2000000000000000LL;
8b06a5c9	201
70fc0674	202	string output = nice_unit_format(two_petabytes, LongUnitFormat, UnitBase1000);
388626dc GMF	203	BOOST_CHECK_EQUAL(string("2.00 PBytes"), output);
388626dc GMF	204
4388cc08	205	output = nice_unit_format(two_petabytes);
8b06a5c9 GMF	206	BOOST_CHECK_EQUAL(string("1.8 PB"), output);
8b06a5c9 GMF	207
388626dc	208	const int64_t two_and_half_petabytes = 2500000000000000LL;
8b06a5c9	209
70fc0674	210	output = nice_unit_format(two_and_half_petabytes, LongUnitFormat, UnitBase1000);
388626dc	211	BOOST_CHECK_EQUAL(string("2.50 PBytes"), output);
8b06a5c9	212
4388cc08	213	output = nice_unit_format(two_and_half_petabytes);
8b06a5c9	214	BOOST_CHECK_EQUAL(string("2.2 PB"), output);
388626dc GMF	215	}
	216
	217	BOOST_AUTO_TEST_CASE(nice_unit_format7)
	218	{
	219	const int64_t two_exabytes = 2000000000000000000LL;
8b06a5c9	220
70fc0674	221	string output = nice_unit_format(two_exabytes, LongUnitFormat, UnitBase1000);
83809f5e	222	BOOST_CHECK_EQUAL(string("2000.00 PBytes"), output);
388626dc	223
4388cc08	224	output = nice_unit_format(two_exabytes);
83809f5e	225	BOOST_CHECK_EQUAL(string("1776.4 PB"), output);
8b06a5c9	226
388626dc	227	const int64_t two_and_half_exabytes = 2500000000000000000LL;
8b06a5c9	228
70fc0674	229	output = nice_unit_format(two_and_half_exabytes, LongUnitFormat, UnitBase1000);
83809f5e	230	BOOST_CHECK_EQUAL(string("2500.00 PBytes"), output);
8b06a5c9	231
4388cc08	232	output = nice_unit_format(two_and_half_exabytes);
83809f5e GMF	233	BOOST_CHECK_EQUAL(string("2220.4 PB"), output);
	234	}
	235
	236	BOOST_AUTO_TEST_CASE(nice_unit_format8)
	237	{
	238	const int64_t max_representable_64bits_number = 9223372036854775807LL;
	239
70fc0674	240	string output = nice_unit_format(max_representable_64bits_number, LongUnitFormat, UnitBase1000);
83809f5e GMF	241	BOOST_CHECK_EQUAL(string("9223.40 PBytes"), output);
83809f5e GMF	242
4388cc08	243	output = nice_unit_format(max_representable_64bits_number);
83809f5e	244	BOOST_CHECK_EQUAL(string("8192.0 PB"), output);
388626dc GMF	245	}
388626dc GMF	246
8b06a5c9 GMF	247
8b06a5c9 GMF	248
9fe0853b TJ	249	BOOST_AUTO_TEST_CASE(imaputf7_to_utf8)
	250	{
	251	string output = utf7imap_to_utf8("Sp&AOQ-m");
	252	BOOST_CHECK_EQUAL(string("Späm"), output);
	253	}
	254
	255	BOOST_AUTO_TEST_CASE(utf8_to_imaputf7)
	256	{
	257	string output = utf8_to_utf7imap("Späm");
	258	BOOST_CHECK_EQUAL(string("Sp&AOQ-m"), output);
	259	}
	260
	261	/*
	262	**
	263	*/
	264
	265	BOOST_AUTO_TEST_CASE(TestTrim)
	266	{
	267	std::string s("s1");
	268	trim_mod(s);
	269	BOOST_CHECK_EQUAL( std::string("s1"), s );
	270
	271	s=" s2";
	272	trim_mod(s);
	273	BOOST_CHECK_EQUAL( std::string("s2"), s );
	274
	275	s="s3 ";
	276	trim_mod(s);
	277	BOOST_CHECK_EQUAL( std::string("s3"), s );
	278
	279	s="::s4:s4::++--aa";
	280	trim_mod(s,":+-a");
	281	BOOST_CHECK_EQUAL( std::string("s4:s4"), s);
	282
	283	/* non modifying version */
	284
	285	s= "s1";
	286	BOOST_CHECK_EQUAL( std::string("s1"), trim(s) );
	287
	288	s=" s2";
	289	BOOST_CHECK_EQUAL( std::string("s2"), trim(s) );
	290	BOOST_CHECK_EQUAL( std::string(" s2"), s );
	291
	292	s="s3 ";
	293	BOOST_CHECK_EQUAL( std::string("s3"), trim(s) );
	294	BOOST_CHECK_EQUAL( std::string("s3 "), s );
	295
	296	s="::s4:s4::++--aa";
	297	BOOST_CHECK_EQUAL( std::string("s4:s4"), trim(s,":+-a") );
	298	} // eo TestTrim()
	299
	300
	301
	302	BOOST_AUTO_TEST_CASE(TestChomp)
	303	{
	304	std::string s("s1");
	305
	306	chomp_mod(s);
	307	BOOST_CHECK_EQUAL( std::string("s1"), s );
	308
	309	s="s2\n";
	310	chomp_mod(s);
	311	BOOST_CHECK_EQUAL( std::string("s2"), s );
	312
313	s="s3:";
314	chomp_mod(s,":");
315	BOOST_CHECK_EQUAL( std::string("s3"), s );
316
317	s=":s4::";
318	chomp_mod(s,"s:");
319	BOOST_CHECK_EQUAL( std::string(":s4:"), s);
320
321	/* non modifiying versions */
322	s= "s1";
323
324	BOOST_CHECK_EQUAL( std::string("s1"), chomp(s) );
325
326	s="s2\n";
327	BOOST_CHECK_EQUAL( std::string("s2"), chomp(s) );
328	BOOST_CHECK_EQUAL( std::string("s2\n"), s);
329
330	s="s3:";
331	BOOST_CHECK_EQUAL( std::string("s3"), chomp(s,":") );
332	BOOST_CHECK_EQUAL( std::string("s3:"), s);
333
334	s=":s4::";
335	BOOST_CHECK_EQUAL( std::string(":s4:"), chomp(s,"s:") );
336	BOOST_CHECK_EQUAL( std::string(":s4::"), s);
337	} // eo TestChomp()
338
339
340
341	BOOST_AUTO_TEST_CASE(TestSuffixFuncs)
342	{
343	std::string s1("12.cpp");
344
345	BOOST_CHECK_EQUAL( true, has_suffix(s1,".cpp") );
346	BOOST_CHECK_EQUAL( true, has_suffix(s1,"pp") );
347	BOOST_CHECK_EQUAL( false, has_suffix(s1,"hpp") );
348	BOOST_CHECK_EQUAL( false, has_suffix(s1,"cp") );
349	BOOST_CHECK_EQUAL( false, has_suffix(s1,"") );
350
351	std::string s1c1= remove_suffix(s1,".cpp");
352	BOOST_CHECK_EQUAL( std::string("12"), s1c1 );
353
354	std::string s1c2= remove_suffix(s1,"p");
355	BOOST_CHECK_EQUAL( std::string("12.cp"), s1c2 );
356
357	std::string s1c3= remove_suffix(s1,"cp");
358	BOOST_CHECK_EQUAL( std::string("12.cpp"), s1c3 );
359
360	std::string s2(".cpp");
361	BOOST_CHECK_EQUAL( true, has_suffix(s2,".cpp") );
362
363	std::string s2c1= remove_suffix(s2,".cpp");
364	BOOST_CHECK_EQUAL( std::string(""), s2c1 );
365
366	} // eo TestSuffixFuncs()
367
368
369
370	BOOST_AUTO_TEST_CASE(TestPrefixFuncs)
371	{
372	std::string s1("12.cpp");
373
374	BOOST_CHECK_EQUAL( true, has_prefix(s1,"12") );
375	BOOST_CHECK_EQUAL( true, has_prefix(s1, "1") );
376	BOOST_CHECK_EQUAL( false, has_prefix(s1, "2") );
377	BOOST_CHECK_EQUAL( false, has_prefix(s1, "") );
378
379	std::string s1c1= remove_prefix(s1, "12");
380	BOOST_CHECK_EQUAL( std::string(".cpp"), s1c1);
381	} // eo TestPrefixFuncs()
382
383
384
385	BOOST_AUTO_TEST_CASE(TestLowerUpperFuncs)
386	{
387	std::string u1("CASE CONVERSION TEST..");
388	std::string l1("case conversion test..");
389
390	std::string test1(l1);
391
392	to_upper_mod(test1);
393	BOOST_CHECK_EQUAL( u1, test1 );
394
395	to_lower_mod(test1);
396	BOOST_CHECK_EQUAL( l1, test1 );
397
398
399	BOOST_CHECK_EQUAL( u1, to_upper(l1) );
400	BOOST_CHECK_EQUAL( l1, to_lower(u1) );
401	} // eo TestLowerUpper
402
403
404
405	BOOST_AUTO_TEST_CASE(PairSplit1)
406	{
407	StringList str_list;
408	get_push_back_filler(str_list)
409	("a=11")("a= 11")("a =11 ")("a = 11 ")(" a = 11 ")
410	;
411	BOOST_CHECK_EQUAL( 5u, str_list.size() );
412	for(StringList::iterator it= str_list.begin();
413	it != str_list.end();
414	++it)
415	{
416	std::string key, value;
417	bool res= pair_split( *it, key, value);
418
419	BOOST_CHECK_EQUAL( true , res );
420	BOOST_CHECK_EQUAL( std::string("a"), key );
421	BOOST_CHECK_EQUAL( std::string("11"), value );
422	}
423
424	std::string key, value;
425	bool res;
426
427	res= pair_split(" 1 : 2 ", key, value, ':');
428	BOOST_CHECK_EQUAL( true, res );
429	BOOST_CHECK_EQUAL( std::string("1"), key);
430	BOOST_CHECK_EQUAL( std::string("2"), value);
431	} // eo PairSplit1
432
433
434
435	BOOST_AUTO_TEST_CASE(SplitString1)
118e216e	436	{
9fe0853b TJ	437	std::string block(
	438	"Zeile 1\n"
	439	"++Zeile-2--\n"
	440	"Zeile 3\n"
	441	"\n"
	442	"Zeile 5\n"
	443	);
	444
	445	StringList list1;
	446
	447	split_string(block, list1, "\n");
	448	// since the blocks ends with \n we should have 6 lines (the last one empty):
	449	BOOST_CHECK_EQUAL( 6u, list1.size() );
	450	BOOST_CHECK_EQUAL( std::string(), list1.back() );
	451	BOOST_CHECK_EQUAL( std::string("Zeile 1"), list1.front() );
	452
	453	StringList list2;
	454
	455	split_string(block, list2, "\n", true);
	456
	457	// now we omitted empty lines, now we should have only 4 lines left:
	458	BOOST_CHECK_EQUAL( 4u, list2.size() );
	459	BOOST_CHECK_EQUAL( std::string("Zeile 5"), list2.back() );
	460	BOOST_CHECK_EQUAL( std::string("Zeile 1"), list2.front() );
	461
	462	list2= split_string(block, "\n", true, "+-");
	463
	464	// again, we omitted empty lines, but also trimmed away leading and trailing "+" and "-"
	465	BOOST_CHECK_EQUAL( 4u, list2.size() );
	466	BOOST_CHECK_EQUAL( std::string("Zeile 5"), list2.back() );
	467	BOOST_CHECK_EQUAL( std::string("Zeile 1"), list2.front() );
	468	BOOST_CHECK_EQUAL( std::string("Zeile-2"), *(++list2.begin()) );
	469	} // eo SplitString1
	470
	471
	472
	473	BOOST_AUTO_TEST_CASE(SplitString2)
	474	{
	475	std::string line("172.16.0.0/16 dev eth0 scope link src 172.16.1.111");
	476
	477	StringList list1;
	478
	479	split_string(line, list1, " ", true, Whitespaces);
	480
	481	BOOST_CHECK_EQUAL( 7u, list1.size() );
	482
	483	} // eo SplitString2
	484
	485
	486
	487	BOOST_AUTO_TEST_CASE(SplitStringEmpty)
	488	{
	489	std::string line("");
	490
	491	StringList list1;
	492
	493	split_string(line, list1, " ", true, Whitespaces);
	494
	495	BOOST_CHECK_EQUAL( 0u, list1.size() );
	496	} // eo SplitStringEmpty
	497
	498
	499	BOOST_AUTO_TEST_CASE(SplitStringDelimiterOnly)
	500	{
501	std::string line(" ");
502
503	StringList list1;
504
505	split_string(line, list1, " ", true, Whitespaces);
506
507	BOOST_CHECK_EQUAL( 0u, list1.size() );
508	} // eo SplitStringDelimiterOnly
509
510
511
512	BOOST_AUTO_TEST_CASE(JoinString1)
513	{
514	std::list< std::string > parts;
515	get_push_back_filler(parts)("1")("2")("drei");
516
517	std::string joined_string= join_string(parts,"/");
518	// we should have slashes between the strings:
519	BOOST_CHECK_EQUAL( std::string("1/2/drei") , joined_string );
520
521	parts.push_back( std::string() );
522	joined_string= join_string(parts,"/");
523	// now we should have an additional trailing slash:
524	BOOST_CHECK_EQUAL( std::string("1/2/drei/") , joined_string );
525
526	parts.push_front( std::string() );
527	joined_string= join_string(parts,"/");
528	// now we should have an additional leading slash:
529	BOOST_CHECK_EQUAL( std::string("/1/2/drei/") , joined_string );
530
531	} // eo JoinString1
532
533
534
535	BOOST_AUTO_TEST_CASE(ConversionStringInt)
536	{
537	std::string s1("24");
538	std::string s1x("25x");
539	int i1=0;
540	bool res= false;
541
542	i1= string_to<int>(s1);
543	BOOST_CHECK_EQUAL( 24, i1 );
544	i1= string_to<int>(s1x);
545	BOOST_CHECK_EQUAL( 25, i1 );
546
547	res= string_to<int>(s1,i1);
548	BOOST_CHECK_EQUAL( true, res );
549	BOOST_CHECK_EQUAL( 24, i1 );
550
551	res= string_to<int>(s1x,i1);
552	BOOST_CHECK_EQUAL( false, res );
553
554	std::string ss1= to_string( 24 );
555	BOOST_CHECK_EQUAL( std::string("24"), ss1);
556
557	} // eo ConversionStringInt()
558
559
560
561	BOOST_AUTO_TEST_CASE(HexConversion)
562	{
563	std::string hex1("49324E");
564	std::string bin1("I2N");
565
566	BOOST_CHECK_EQUAL( hex1, convert_binary_to_hex(bin1,true) );
567	BOOST_CHECK_EQUAL( bin1, convert_hex_to_binary(hex1) );
568	BOOST_CHECK_EQUAL( to_lower(hex1), convert_binary_to_hex(bin1) );
569
570	std::string hex2("0001");
571	std::string hex2a("00 01");
572	std::string hex2b("00:01");
573	std::string bin2("\0\1",2);
574
575	BOOST_CHECK_EQUAL( hex2, convert_binary_to_hex(bin2) );
576	BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2) );
577	BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2a) );
578	BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2b) );
579
580	BOOST_REQUIRE_THROW( convert_hex_to_binary("01 kein hex"), std::runtime_error);
581	} // eo HexConversion()
582
583	BOOST_AUTO_TEST_SUITE_END()