cppuhelper/qa/unourl/cppu_unourl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <cppunit/TestFixture.h>
  21 #include <cppunit/extensions/HelperMacros.h>
  22 #include <cppunit/plugin/TestPlugIn.h>
  23
  24 #include <cppuhelper/unourl.hxx>
  25 #include <rtl/malformeduriexception.hxx>
  26 #include <rtl/ustring.hxx>
  27 #include <sal/types.h>
  28
  29 namespace cppu_unourl
  30 {
  31     class UrlTest : public CppUnit::TestFixture
  32     {
  33     public:
  34         void testDescriptorParsing()
  35         {
  36             struct Test
  37             {
  38                 char const * pInput;
  39                 bool bValid;
  40             };
  41             static Test const aTests[]
  42                 = { { "", false },
  43                     { "abc", true },
  44                     { "Abc", true },
  45                     { "aBC", true },
  46                     { "ABC", true },
  47                     { "1abc", true },
  48                     { "123", true },
  49                     { "abc-1", false },
  50                     { "ab%63", false },
  51                     { "abc,", false },
  52                     { "abc,def=", true },
  53                     { "abc,Def=", true },
  54                     { "abc,DEF=", true },
  55                     { "abc,1def=", true },
  56                     { "abc,123=", true },
  57                     { "abc,def-1=", false },
  58                     { "abc,def", false },
  59                     { "abc,def=xxx,def=xxx", false },
  60                     { "abc,def=xxx,ghi=xxx", true },
  61                     { "abc,,def=xxx", false },
  62                     { "abc,def=xxx,,ghi=xxx", false },
  63                     { "abc,def=xxx,ghi=xxx,", false },
  64                     { "abc,def=%", true },
  65                     { "abc,def=%1", true },
  66                     { "abc,def=%00", true },
  67                     { "abc,def=%22", true },
  68                     { "abc,def=\"", true },
  69                     { "abc,def=%ed%a0%80", true } };
  70             for (size_t i = 0; i < std::size(aTests); ++i)
  71             {
  72                 bool bValid = false;
  73                 try
  74                 {
  75                     cppu::UnoUrlDescriptor aDescriptor(OUString::createFromAscii(
  76                                                            aTests[i].pInput));
  77                     (void)aDescriptor;
  78                     bValid = true;
  79                 }
  80                 catch (rtl::MalformedUriException &)
  81                 {}
  82
  83                 if (aTests[i].bValid)
  84                 {
  85                     CPPUNIT_ASSERT_MESSAGE("Valid uri parsed as invalid", bValid);
  86                 }
  87                 else
  88                 {
  89                     CPPUNIT_ASSERT_MESSAGE("Invalid uri parsed as valid", !bValid);
  90                 }
  91             }
  92         }
  93
  94         void testDescriptorDescriptor()
  95         {
  96             struct Test
  97             {
  98                 char const * pInput;
  99                 char const * pDescriptor;
 100             };
 101             static Test const aTests[]
 102                 = {{ "abc", "abc" },
 103                    { "Abc", "Abc" },
 104                    { "aBC", "aBC" },
 105                    { "ABC", "ABC" },
 106                    { "1abc", "1abc" },
 107                    { "123", "123" },
 108                    { "abc,def=", "abc,def=" },
 109                    { "abc,Def=", "abc,Def=" },
 110                    { "abc,DEF=", "abc,DEF=" },
 111                    { "abc,1def=", "abc,1def=" },
 112                    { "abc,123=", "abc,123=" },
 113                    { "abc,def=xxx,ghi=xxx", "abc,def=xxx,ghi=xxx" },
 114                    { "abc,def=%", "abc,def=%" },
 115                    { "abc,def=%1", "abc,def=%1" },
 116                    { "abc,def=%00", "abc,def=%00" },
 117                    { "abc,def=%22", "abc,def=%22" },
 118                    { "abc,def=\"", "abc,def=\"" },
 119                    { "abc,def=%ed%a0%80", "abc,def=%ed%a0%80" } };
 120             for (size_t i = 0; i < std::size(aTests); ++i)
 121             {
 122                 bool bValid = false;
 123                 OUString aDescriptor;
 124                 try
 125                 {
 126                     aDescriptor = cppu::UnoUrlDescriptor(OUString::createFromAscii(
 127                                                              aTests[i].pInput)).
 128                         getDescriptor();
 129                     bValid = true;
 130                 }
 131                 catch (rtl::MalformedUriException &)
 132                 {}
 133
 134                 CPPUNIT_ASSERT_MESSAGE("Failed to parse URI", bValid);
 135                 CPPUNIT_ASSERT_MESSAGE("Failed to parse URI correctly",
 136                                        aDescriptor.equalsAscii(
 137                                            aTests[i].pDescriptor));
 138             }
 139         }
 140
 141
 142         void testDescriptorName()
 143         {
 144             struct Test
 145             {
 146                 char const * pInput;
 147                 char const * pName;
 148             };
 149             static Test const aTests[]
 150                 = { { "abc", "abc" },
 151                     { "Abc", "abc" },
 152                     { "aBC", "abc" },
 153                     { "ABC", "abc" },
 154                     { "1abc", "1abc" },
 155                     { "123", "123" },
 156                     { "abc,def=", "abc" },
 157                     { "abc,Def=", "abc" },
 158                     { "abc,DEF=", "abc" },
 159                     { "abc,1def=", "abc" },
 160                     { "abc,123=", "abc" },
 161                     { "abc,def=xxx,ghi=xxx", "abc" },
 162                     { "abc,def=%", "abc" },
 163                     { "abc,def=%1", "abc" },
 164                     { "abc,def=%00", "abc" },
 165                     { "abc,def=%22", "abc" },
 166                     { "abc,def=\"", "abc" },
 167                     { "abc,def=%ed%a0%80", "abc" } };
 168             for (size_t i = 0; i < std::size(aTests); ++i)
 169             {
 170                 bool bValid = false;
 171                 OUString aName;
 172                 try
 173                 {
 174                     aName = cppu::UnoUrlDescriptor(OUString::createFromAscii(
 175                                                        aTests[i].pInput)).getName();
 176                     bValid = true;
 177                 }
 178                 catch (rtl::MalformedUriException &)
 179                 {}
 180
 181                 CPPUNIT_ASSERT_MESSAGE("Failed to parse URI", bValid);
 182                 CPPUNIT_ASSERT_MESSAGE("Failed to parse URI correctly",
 183                                        aName.equalsAscii(aTests[i].pName));
 184             }
 185         }
 186
 187         void testDescriptorKey()
 188         {
 189             struct Test
 190             {
 191                 char const * pInput;
 192                 char const * pKey;
 193                 bool bPresent;
 194             };
 195             static Test const aTests[]
 196                 = { { "abc", "abc", false },
 197                     { "abc", "def", false },
 198                     { "1abc", "def", false },
 199                     { "123", "def", false },
 200                     { "abc,def=", "abc", false },
 201                     { "abc,def=", "def", true },
 202                     { "abc,def=", "defg", false },
 203                     { "abc,def=", "de", false },
 204                     { "abc,def=", "ghi", false },
 205                     { "abc,Def=", "def", true },
 206                     { "abc,Def=", "Def", true },
 207                     { "abc,Def=", "dEF", true },
 208                     { "abc,Def=", "DEF", true },
 209                     { "abc,def=xxx,ghi=xxx", "abc", false },
 210                     { "abc,def=xxx,ghi=xxx", "def", true },
 211                     { "abc,def=xxx,ghi=xxx", "ghi", true },
 212                     { "abc,def=xxx,ghi=xxx", "jkl", false } };
 213             for (size_t i = 0; i < std::size(aTests); ++i)
 214             {
 215                 bool bValid = false;
 216                 bool bPresent = false;
 217                 try
 218                 {
 219                     bPresent = cppu::UnoUrlDescriptor(OUString::createFromAscii(
 220                                                           aTests[i].pInput)).
 221                         hasParameter(OUString::createFromAscii(aTests[i].pKey));
 222                     bValid = true;
 223                 }
 224                 catch (rtl::MalformedUriException &)
 225                 {}
 226
 227                 CPPUNIT_ASSERT_MESSAGE("Failed to parse URI", bValid);
 228                 CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to detect parameter correctly",
 229                                        aTests[i].bPresent, bPresent);
 230             }
 231         }
 232
 233         void testDescriptorValue()
 234         {
 235             struct Test
 236             {
 237                 char const * pInput;
 238                 char const * pKey;
 239                 char const * pValue;
 240             };
 241             static Test const aTests[]
 242                 = { { "abc", "abc", "" },
 243                     { "abc", "def", "" },
 244                     { "1abc", "def", "" },
 245                     { "123", "def", "" },
 246                     { "abc,def=", "abc", "" },
 247                     { "abc,def=", "def", "" },
 248                     { "abc,def=", "defg", "" },
 249                     { "abc,def=", "de", "" },
 250                     { "abc,def=", "ghi", "" },
 251                     { "abc,Def=", "def", "" },
 252                     { "abc,Def=", "Def", "" },
 253                     { "abc,Def=", "dEF", "" },
 254                     { "abc,Def=", "DEF", "" },
 255                     { "abc,def=xxx,ghi=xxx", "abc", "" },
 256                     { "abc,def=xxx,ghi=xxx", "def", "xxx" },
 257                     { "abc,def=xxx,ghi=xxx", "ghi", "xxx" },
 258                     { "abc,def=xxx,ghi=xxx", "jkl", "" },
 259                     { "abc,def=%", "def", "%" },
 260                     { "abc,def=%1", "def", "%1" },
 261                     { "abc,def=%22", "def", "\"" },
 262                     { "abc,def=\"", "def", "\"" },
 263                     { "abc,def=abc", "def", "abc" },
 264                     { "abc,def=Abc", "def", "Abc" },
 265                     { "abc,def=aBC", "def", "aBC" },
 266                     { "abc,def=ABC", "def", "ABC" },
 267                     { "abc,def=%,ghi=", "def", "%" },
 268                     { "abc,def=%1,ghi=", "def", "%1" },
 269                     { "abc,def=%22,ghi=", "def", "\"" },
 270                     { "abc,def=\",ghi=", "def", "\"" },
 271                     { "abc,def=abc,ghi=", "def", "abc" },
 272                     { "abc,def=Abc,ghi=", "def", "Abc" },
 273                     { "abc,def=aBC,ghi=", "def", "aBC" },
 274                     { "abc,def=ABC,ghi=", "def", "ABC" },
 275                     { "abc,abc=,def=%", "def", "%" },
 276                     { "abc,abc=,def=%1", "def", "%1" },
 277                     { "abc,abc=,def=%22", "def", "\"" },
 278                     { "abc,abc=,def=\"", "def", "\"" },
 279                     { "abc,abc=,def=abc", "def", "abc" },
 280                     { "abc,abc=,def=Abc", "def", "Abc" },
 281                     { "abc,abc=,def=aBC", "def", "aBC" },
 282                     { "abc,abc=,def=ABC", "def", "ABC" } };
 283             for (size_t i = 0; i < std::size(aTests); ++i)
 284             {
 285                 bool bValid = false;
 286                 OUString aValue;
 287                 try
 288                 {
 289                     aValue = cppu::UnoUrlDescriptor(OUString::createFromAscii(
 290                                                         aTests[i].pInput)).
 291                         getParameter(OUString::createFromAscii(aTests[i].pKey));
 292                     bValid = true;
 293                 }
 294                 catch (rtl::MalformedUriException &)
 295                 {}
 296                 CPPUNIT_ASSERT_MESSAGE("Failed to parse URI", bValid);
 297                 CPPUNIT_ASSERT_MESSAGE("Failed to get param correctly",
 298                                        aValue.equalsAscii(aTests[i].pValue));
 299             }
 300         }
 301
 302         void testUrlParsing()
 303         {
 304             struct Test
 305             {
 306                 char const * pInput;
 307                 bool bValid;
 308             };
 309             static Test const aTests[]
 310                 = { { "", false },
 311                     { "abc", false },
 312                     { "uno", false },
 313                     { "uno:", false },
 314                     { "uno:abc;def;ghi", true },
 315                     { "Uno:abc;def;ghi", true },
 316                     { "uNO:abc;def;ghi", true },
 317                     { "UNO:abc;def;ghi", true },
 318                     { "uno:abc,def=xxx,ghi=xxx;def,ghi=xxx,jkl=xxx;ghi", true },
 319                     { "uno:abc,def=xxx,ghi=xxx;def,ghi=xxx,jkl=xxx,;ghi", false },
 320                     { "uno:abc;def;", false },
 321                     { "uno:abc;def;a", true },
 322                     { "uno:abc;def;A", true },
 323                     { "uno:abc;def;1", true },
 324                     { "uno:abc;def;$&+,/:=?@", true },
 325                     { "uno:abc;def;%24&+,/:=?@", false } };
 326             for (size_t i = 0; i < std::size(aTests); ++i)
 327             {
 328                 bool bValid = false;
 329                 try
 330                 {
 331                     cppu::UnoUrl aUrl(OUString::createFromAscii(aTests[i].pInput));
 332                     (void)aUrl;
 333                     bValid = true;
 334                 }
 335                 catch (rtl::MalformedUriException &)
 336                 {}
 337
 338                 if (aTests[i].bValid)
 339                 {
 340                     CPPUNIT_ASSERT_MESSAGE("Valid uri parsed as invalid", bValid);
 341                 }
 342                 else
 343                 {
 344                     CPPUNIT_ASSERT_MESSAGE("Invalid uri parsed as valid", !bValid);
 345                 }
 346
 347             }
 348         }
 349
 350         void testUrlConnection()
 351         {
 352             struct Test
 353             {
 354                 char const * pInput;
 355                 char const * pConnection;
 356             };
 357             static Test const aTests[]
 358                 = { { "uno:abc;def;ghi", "abc" },
 359                     { "uno:Abc;def;ghi", "Abc" },
 360                     { "uno:aBC;def;ghi", "aBC" },
 361                     { "uno:ABC;def;ghi", "ABC" },
 362                     { "uno:abc,def=xxx,ghi=xxx;def,ghi=xxx,jkl=xxx;ghi",
 363                       "abc,def=xxx,ghi=xxx" } };
 364             for (size_t i = 0; i < std::size(aTests); ++i)
 365             {
 366                 bool bValid = false;
 367                 OUString aConnection;
 368                 try
 369                 {
 370                     aConnection = cppu::UnoUrl(OUString::createFromAscii(
 371                                                    aTests[i].pInput)).
 372                         getConnection().getDescriptor();
 373                     bValid = true;
 374                 }
 375                 catch (rtl::MalformedUriException &)
 376                 {}
 377                 CPPUNIT_ASSERT_MESSAGE("Failed to parse URI", bValid);
 378                 CPPUNIT_ASSERT_MESSAGE("Failed to get param correctly",
 379                                        aConnection.equalsAscii(
 380                                            aTests[i].pConnection));
 381             }
 382         }
 383
 384         void testUrlProtocol()
 385         {
 386             struct Test
 387             {
 388                 char const * pInput;
 389                 char const * pProtocol;
 390             };
 391             static Test const aTests[]
 392                 = { { "uno:abc;def;ghi", "def" },
 393                     { "uno:abc;Def;ghi", "Def" },
 394                     { "uno:abc;dEF;ghi", "dEF" },
 395                     { "uno:abc;DEF;ghi", "DEF" },
 396                     { "uno:abc,def=xxx,ghi=xxx;def,ghi=xxx,jkl=xxx;ghi",
 397                       "def,ghi=xxx,jkl=xxx" } };
 398             for (size_t i = 0; i < std::size(aTests); ++i)
 399             {
 400                 bool bValid = false;
 401                 OUString aProtocol;
 402                 try
 403                 {
 404                     aProtocol = cppu::UnoUrl(OUString::createFromAscii(
 405                                                  aTests[i].pInput)).
 406                         getProtocol().getDescriptor();
 407                     bValid = true;
 408                 }
 409                 catch (rtl::MalformedUriException &)
 410                 {}
 411                 CPPUNIT_ASSERT_MESSAGE("Failed to parse URI", bValid);
 412                 CPPUNIT_ASSERT_MESSAGE("Failed to get protocol correctly",
 413                                        aProtocol.equalsAscii(
 414                                            aTests[i].pProtocol));
 415             }
 416         }
 417
 418         void testUrlObjectName()
 419         {
 420             struct Test
 421             {
 422                 char const * pInput;
 423                 char const * pObjectName;
 424             };
 425             static Test const aTests[]
 426                 = { { "uno:abc;def;ghi", "ghi" },
 427                     { "uno:abc;def;Ghi", "Ghi" },
 428                     { "uno:abc;def;gHI", "gHI" },
 429                     { "uno:abc;def;GHI", "GHI" },
 430                     { "uno:abc,def=xxx,ghi=xxx;def,ghi=xxx,jkl=xxx;ghi", "ghi" },
 431                     { "uno:abc;def;a", "a" },
 432                     { "uno:abc;def;A", "A" },
 433                     { "uno:abc;def;1", "1" },
 434                     { "uno:abc;def;$&+,/:=?@", "$&+,/:=?@" } };
 435             for (size_t i = 0; i < std::size(aTests); ++i)
 436             {
 437                 bool bValid = false;
 438                 OUString aObjectName;
 439                 try
 440                 {
 441                     aObjectName = cppu::UnoUrl(OUString::createFromAscii(
 442                                                    aTests[i].pInput)).getObjectName();
 443                     bValid = true;
 444                 }
 445                 catch (rtl::MalformedUriException &)
 446                 {}
 447                 CPPUNIT_ASSERT_MESSAGE("Failed to parse URI", bValid);
 448                 CPPUNIT_ASSERT_MESSAGE("Failed to get protocol correctly",
 449                                        aObjectName.equalsAscii(
 450                                            aTests[i].pObjectName));
 451             }
 452         }
 453
 454         // Automatic registration code
 455         CPPUNIT_TEST_SUITE(UrlTest);
 456         CPPUNIT_TEST(testDescriptorParsing);
 457         CPPUNIT_TEST(testDescriptorDescriptor);
 458         CPPUNIT_TEST(testDescriptorName);
 459         CPPUNIT_TEST(testDescriptorKey);
 460         CPPUNIT_TEST(testDescriptorValue);
 461         CPPUNIT_TEST(testUrlParsing);
 462         CPPUNIT_TEST(testUrlConnection);
 463         CPPUNIT_TEST(testUrlProtocol);
 464         CPPUNIT_TEST(testUrlObjectName);
 465         CPPUNIT_TEST_SUITE_END();
 466     };
 467 } // namespace cppu_ifcontainer
 468
 469 CPPUNIT_TEST_SUITE_REGISTRATION(cppu_unourl::UrlTest);
 470
 471 CPPUNIT_PLUGIN_IMPLEMENT();
 472
 473 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */