tests/zypp/base/String_test.cc

   1 #include <boost/test/auto_unit_test.hpp>
   2
   3 #include "zypp/base/LogTools.h"
   4 #include "zypp/base/String.h"
   5
   6 using boost::unit_test::test_suite;
   7 using boost::unit_test::test_case;
   8 using namespace boost::unit_test;
   9
  10 using namespace std;
  11 using namespace zypp;
  12 using namespace zypp::str;
  13
  14 BOOST_AUTO_TEST_CASE(gsubTest)
  15 {
  16   string olds = "olds";
  17   string news = "new string";
  18
  19   BOOST_CHECK_EQUAL(gsub("test olds string",olds,news), "test new string string");
  20   BOOST_CHECK_EQUAL(gsub("no string",olds,news),"no string");
  21   BOOST_CHECK_EQUAL(gsub("oldsolds",olds,news),"new stringnew string");
  22 }
  23
  24 BOOST_AUTO_TEST_CASE(replaceAllTest)
  25 {
  26   string olds = "olds";
  27   string news = "new string";
  28   string tests;
  29
  30   tests = "test olds string";
  31   replaceAll(tests,olds,news);
  32   BOOST_CHECK_EQUAL(tests, "test new string string");
  33
  34   tests = "no string";
  35   replaceAll(tests,olds,news);
  36   BOOST_CHECK_EQUAL(tests, "no string");
  37
  38   tests = "oldsolds";
  39   replaceAll(tests,olds,news);
  40   BOOST_CHECK_EQUAL(tests, "new stringnew string");
  41 }
  42
  43 BOOST_AUTO_TEST_CASE(testsplitEscaped)
  44 {
  45   string s( "simple non-escaped string" );
  46   vector<string> v;
  47
  48   insert_iterator<vector<string> > ii (v,v.end());
  49   splitEscaped( s, ii );
  50   BOOST_CHECK_EQUAL( v.size(), 3 );
  51
  52   v.clear();
  53   s = string( "\"escaped sentence \"" );
  54   ii = insert_iterator<vector<string> >( v, v.end() );
  55   splitEscaped( s, ii );
  56   BOOST_CHECK_EQUAL( v.size(), 1 );
  57   BOOST_CHECK_EQUAL( v.front(), string( "escaped sentence " ) );
  58
  59    v.clear();
  60    s = string( "\"escaped \\\\sent\\\"ence \\\\\"" );
  61    ii = insert_iterator<vector<string> >( v, v.end() );
  62    splitEscaped( s, ii );
  63    BOOST_CHECK_EQUAL( v.size(), 1 );
  64    BOOST_CHECK_EQUAL( v.front(), string( "escaped \\sent\"ence \\" ) );
  65
  66
  67    v.clear();
  68    s = string( "escaped sentence\\ with\\ space" );
  69    ii = insert_iterator<vector<string> >( v, v.end() );
  70    splitEscaped( s, ii );
  71    BOOST_CHECK_EQUAL( v.size(), 2 );
  72    BOOST_CHECK_EQUAL( v[1], string( "sentence with space" ) );
  73
  74    // split - join
  75    v.clear();
  76    s = "some line \"\" foo\\ a foo\\\\ b";
  77    str::splitEscaped( s, std::back_inserter(v) );
  78    BOOST_CHECK_EQUAL( s, str::joinEscaped( v.begin(), v.end() ) );
  79
  80    // split - join using alternate sepchar
  81    s = str::joinEscaped( v.begin(), v.end(), 'o' );
  82    v.clear();
  83    str::splitEscaped( s, std::back_inserter(v), "o" );
  84    BOOST_CHECK_EQUAL( s, str::joinEscaped( v.begin(), v.end(), 'o' ) );
  85 }
  86
  87 BOOST_AUTO_TEST_CASE(testsplitEscapedWithEmpty)
  88 {
  89   string s( "simple:non-escaped:string" );
  90   vector<string> v;
  91
  92   BOOST_CHECK_EQUAL(splitFieldsEscaped(s, std::back_inserter(v)), 3);
  93   BOOST_CHECK_EQUAL(v.size(), 3);
  94
  95   v.clear();
  96   s = "non-escaped:with::spaces:";
  97   BOOST_CHECK_EQUAL(splitFieldsEscaped(s, std::back_inserter(v)), 5);
  98   BOOST_CHECK_EQUAL(v.size(), 5);
  99
 100   v.clear();
 101   s = "::";
 102   BOOST_CHECK_EQUAL(splitFieldsEscaped(s, std::back_inserter(v)), 3);
 103   BOOST_CHECK_EQUAL(v.size(), 3);
 104
 105   v.clear();
 106   s = ":escaped::with\\:spaces";
 107   BOOST_CHECK_EQUAL(splitFieldsEscaped(s, std::back_inserter(v)), 4);
 108   BOOST_CHECK_EQUAL(v.size(), 4);
 109 }
 110
 111 BOOST_AUTO_TEST_CASE(test_escape)
 112 {
 113   string badass = "bad|ass\\|worse";
 114   string escaped = str::escape(badass, '|');
 115
 116   BOOST_CHECK_EQUAL( escaped, "bad\\|ass\\\\\\|worse" );
 117 }
 118
 119 BOOST_AUTO_TEST_CASE(conversions)
 120 {
 121     BOOST_CHECK_EQUAL(str::numstring(42),     "42");
 122     BOOST_CHECK_EQUAL(str::numstring(42, 6),  "    42");
 123     BOOST_CHECK_EQUAL(str::numstring(42, -6), "42    ");
 124
 125     BOOST_CHECK_EQUAL(str::hexstring(42),     "0x0000002a");
 126     BOOST_CHECK_EQUAL(str::hexstring(42, 6),  "0x002a");
 127     BOOST_CHECK_EQUAL(str::hexstring(42, -6), "0x2a  ");
 128
 129     BOOST_CHECK_EQUAL(str::octstring(42),     "00052");
 130     BOOST_CHECK_EQUAL(str::octstring(42, 6),  "000052");
 131     BOOST_CHECK_EQUAL(str::octstring(42, -6), "052   ");
 132
 133     BOOST_CHECK_EQUAL(str::strtonum<int>("42"), 42);
 134
 135     BOOST_CHECK_EQUAL(str::toLower("This IS A TeST"), "this is a test");
 136     BOOST_CHECK_EQUAL(str::toUpper("This IS A TeST"), "THIS IS A TEST");
 137     BOOST_CHECK_EQUAL(str::compareCI("TeST", "test"), 0);
 138
 139     BOOST_CHECK_EQUAL(str::compareCI("TeST", "test"), 0);
 140     BOOST_CHECK_EQUAL(str::compareCI("TeST", "test"), 0);
 141 }
 142
 143 BOOST_AUTO_TEST_CASE(conversions_to_bool)
 144 {
 145   // true iff true-string {1,on,yes,true}
 146   BOOST_CHECK_EQUAL( str::strToTrue("1"),     true );
 147   BOOST_CHECK_EQUAL( str::strToTrue("42"),    true );
 148   BOOST_CHECK_EQUAL( str::strToTrue("ON"),    true );
 149   BOOST_CHECK_EQUAL( str::strToTrue("YES"),   true );
 150   BOOST_CHECK_EQUAL( str::strToTrue("TRUE"),  true );
 151   BOOST_CHECK_EQUAL( str::strToTrue("0"),     false );
 152   BOOST_CHECK_EQUAL( str::strToTrue("OFF"),   false );
 153   BOOST_CHECK_EQUAL( str::strToTrue("NO"),    false );
 154   BOOST_CHECK_EQUAL( str::strToTrue("FALSE"), false );
 155   BOOST_CHECK_EQUAL( str::strToTrue(""),      false );
 156   BOOST_CHECK_EQUAL( str::strToTrue("foo"),   false );
 157
 158   // false iff false-string {0,off,no,false}
 159   BOOST_CHECK_EQUAL( str::strToFalse("1"),     true );
 160   BOOST_CHECK_EQUAL( str::strToFalse("42"),    true );
 161   BOOST_CHECK_EQUAL( str::strToFalse("ON"),    true );
 162   BOOST_CHECK_EQUAL( str::strToFalse("YES"),   true );
 163   BOOST_CHECK_EQUAL( str::strToFalse("TRUE"),  true );
 164   BOOST_CHECK_EQUAL( str::strToFalse("0"),     false );
 165   BOOST_CHECK_EQUAL( str::strToFalse("OFF"),   false );
 166   BOOST_CHECK_EQUAL( str::strToFalse("NO"),    false );
 167   BOOST_CHECK_EQUAL( str::strToFalse("FALSE"), false );
 168   BOOST_CHECK_EQUAL( str::strToFalse(""),      true );
 169   BOOST_CHECK_EQUAL( str::strToFalse("foo"),   true );
 170
 171   // true iff true-string
 172   BOOST_CHECK_EQUAL( str::strToBool("TRUE",  false), true );
 173   BOOST_CHECK_EQUAL( str::strToBool("FALSE", false), false );
 174   BOOST_CHECK_EQUAL( str::strToBool("",      false), false );
 175   BOOST_CHECK_EQUAL( str::strToBool("foo",   false), false );
 176
 177   // false iff false-string
 178   BOOST_CHECK_EQUAL( str::strToBool("TRUE",  true),  true );
 179   BOOST_CHECK_EQUAL( str::strToBool("FALSE", true),  false );
 180   BOOST_CHECK_EQUAL( str::strToBool("",      true),  true );
 181   BOOST_CHECK_EQUAL( str::strToBool("foo",   true),  true );
 182
 183   // true/false iff true/false-string, else unchanged
 184   bool ret;
 185   ret = true; BOOST_CHECK_EQUAL( str::strToBoolNodefault("TRUE",  ret),  true );
 186   ret = true; BOOST_CHECK_EQUAL( str::strToBoolNodefault("FALSE", ret),  false );
 187   ret = true; BOOST_CHECK_EQUAL( str::strToBoolNodefault("",      ret),  true );
 188   ret = true; BOOST_CHECK_EQUAL( str::strToBoolNodefault("foo",   ret),  true );
 189
 190   ret = false; BOOST_CHECK_EQUAL( str::strToBoolNodefault("TRUE",  ret),  true );
 191   ret = false; BOOST_CHECK_EQUAL( str::strToBoolNodefault("FALSE", ret),  false );
 192   ret = false; BOOST_CHECK_EQUAL( str::strToBoolNodefault("",      ret),  false );
 193   ret = false; BOOST_CHECK_EQUAL( str::strToBoolNodefault("foo",   ret),  false );
 194 }
 195
 196 BOOST_AUTO_TEST_CASE(operations)
 197 {
 198     BOOST_CHECK_EQUAL(str::ltrim(" \t f \t ffo \t "), "f \t ffo \t ");
 199     BOOST_CHECK_EQUAL(str::rtrim(" \t f \t ffo \t "), " \t f \t ffo");
 200     BOOST_CHECK_EQUAL(str::trim(" \t f \t ffo \t "),  "f \t ffo");
 201
 202     // strip first
 203     {
 204         string tostrip(" Oh! la la ");
 205         string word( str::stripFirstWord(tostrip, true) ); // ltrim first
 206         BOOST_CHECK_EQUAL(word, "Oh!");
 207         BOOST_CHECK_EQUAL(tostrip, "la la ");
 208     }
 209     {
 210         string tostrip(" Oh! la la ");
 211         string word( str::stripFirstWord(tostrip, false) ); // no ltrim first
 212         BOOST_CHECK_EQUAL(word, "");
 213         BOOST_CHECK_EQUAL(tostrip, "Oh! la la ");
 214     }
 215
 216     // strip last
 217     {
 218         string tostrip(" Oh! la la ");
 219         string word( str::stripLastWord(tostrip, true) ); // rtrim first
 220         BOOST_CHECK_EQUAL(word, "la");
 221         BOOST_CHECK_EQUAL(tostrip, " Oh! la");
 222     }
 223     {
 224         string tostrip(" Oh! la la ");
 225         string word( str::stripLastWord(tostrip, false) ); // no rtrim first
 226         BOOST_CHECK_EQUAL(word, "");
 227         BOOST_CHECK_EQUAL(tostrip, " Oh! la la");
 228     }
 229 }
 230
 231 BOOST_AUTO_TEST_CASE(prefix_suffix)
 232 {
 233   BOOST_CHECK( str::hasPrefix("abcXabcYabc", "abcX") );
 234   BOOST_CHECK( str::hasSuffix("abcXabcYabc", "Yabc") );
 235
 236   BOOST_CHECK_EQUAL( str::stripPrefix("abcXabcYabc", "abcX"),  "abcYabc" );
 237   BOOST_CHECK_EQUAL( str::stripSuffix("abcXabcYabc", "Yabc"),  "abcXabc" );
 238
 239   BOOST_CHECK( ! str::hasPrefix("abcXabcYabc", "ac") );
 240   BOOST_CHECK( ! str::hasSuffix("abcXabcYabc", "ac") );
 241
 242   BOOST_CHECK_EQUAL( str::stripPrefix("abcXabcYabc", "ac"),  "abcXabcYabc" );
 243   BOOST_CHECK_EQUAL( str::stripSuffix("abcXabcYabc", "ac"),  "abcXabcYabc" );
 244
 245   BOOST_CHECK( str::startsWith("abcXabcYabc", "abc") );
 246   BOOST_CHECK( str::endsWith("abcXabcYabc", "abc") );
 247
 248   BOOST_CHECK( str::contains("abcXabcYabc", "XabcY") );
 249   BOOST_CHECK( ! str::contains("abcXabcYabc", "xabcy") );
 250   BOOST_CHECK( str::containsCI("abcXabcYabc", "xabcy") );
 251 }
 252
 253 BOOST_AUTO_TEST_CASE(hexencode_hexdecode)
 254 {
 255   std::string o;
 256   o.reserve( 256 );
 257   for ( unsigned i = 1; i < 256; ++i )
 258     o += i;
 259
 260   std::string e( str::hexencode( o ) );
 261   // encoded contains nothing but [%a-zA-Z0-9]
 262   for ( unsigned i = 0; i < 255; ++i )
 263   {
 264     char ch = e[i];
 265     BOOST_CHECK( ch == '%'
 266                  || ( 'a' <= ch && ch <= 'z' )
 267                  || ( 'A' <= ch && ch <= 'Z' )
 268                  || ( '0' <= ch && ch <= '9' ) );
 269   }
 270
 271   std::string d( str::hexdecode( e ) );
 272   BOOST_CHECK( o == d );
 273 //   for ( unsigned i = 0; i < 255; ++i )
 274 //     if ( o[i] != d[i] )
 275 //       WAR << i << " " << unsigned(o[i]) << " != " << unsigned(d[i]) << endl;
 276 }