unoxml/qa/unit/domtest.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 <rtl/ref.hxx>
  21 #include <sal/log.hxx>
  22 #include <sax/fastattribs.hxx>
  23 #include <comphelper/seqstream.hxx>
  24 #include <cppuhelper/implbase.hxx>
  25 #include <cppunit/extensions/HelperMacros.h>
  26 #include <cppunit/plugin/TestPlugIn.h>
  27 #include <test/bootstrapfixture.hxx>
  28
  29 #include <com/sun/star/xml/dom/XDocumentBuilder.hpp>
  30 #include <com/sun/star/xml/sax/FastToken.hpp>
  31 #include <com/sun/star/xml/sax/XSAXSerializable.hpp>
  32 #include <com/sun/star/xml/sax/XFastSAXSerializable.hpp>
  33 #include <com/sun/star/xml/sax/SAXParseException.hpp>
  34
  35 using namespace ::comphelper;
  36 using namespace ::com::sun::star;
  37 using namespace ::com::sun::star::uno;
  38 using css::xml::dom::XDocumentBuilder;
  39
  40 namespace
  41 {
  42 // valid xml
  43 const char validTestFile[] =
  44 "<?xml version=\"1.0\" encoding=\"UTF-8\"?> \
  45  <office:document-content \
  46    xmlns:office=\"urn:oasis:names:tc:opendocument:xmlns:office:1.0\" \
  47    xmlns:xlink=\"http://www.w3.org/1999/xlink\" \
  48    office:version=\"1.0\"> \
  49    <office:scripts/> \
  50    <xlink:test/> \
  51    <office:automatic-styles teststyle=\"test\"/> \
  52    <moretest/> \
  53     some text \303\266\303\244\303\274 \
  54  </office:document-content> \
  55 ";
  56
  57 // generates a warning: unknown xml:space
  58 // value
  59 const char warningTestFile[] =
  60 "<?xml version=\"1.0\" encoding=\"UTF-8\"?> \
  61  <office:document-content \
  62    xmlns:office=\"urn:oasis:names:tc:opendocument:xmlns:office:1.0\" \
  63    xml:space=\"blah\" \
  64    xmlns:xlink=\"http://www.w3.org/1999/xlink\" \
  65    office:version=\"1.0\"> \
  66    <office:scripts/> \
  67    <xlink:test/> \
  68    <office:automatic-styles teststyle=\"test\"/> \
  69    <moretest/> \
  70     some text \303\266\303\244\303\274 \
  71  </office:document-content> \
  72 ";
  73
  74 // <?xml not at start of file
  75 const char errorTestFile[] =
  76 " <?xml version=\"1.0\" encoding=\"UTF-8\"?> \
  77  <office:document-content \
  78    xmlns:office=\"urn:oasis:names:tc:opendocument:xmlns:office:1.0\" \
  79    office:version=\"1.0\"> \
  80    <office:scripts/> \
  81    <office:automatic-styles/> \
  82  </office:document-content> \
  83 ";
  84
  85 struct ErrorHandler
  86     : public ::cppu::WeakImplHelper< xml::sax::XErrorHandler >
  87 {
  88     sal_uInt32 mnErrCount;
  89 //    sal_uInt32 mnFatalCount;  // No fatal error counter, as lib2xml doesn't distinguish between error and fatal error
  90                                 // (see See xmlFatalErrMsg from lib2xml/parse.c and __xmlRaiseError from lib2xml/error.c)
  91     sal_uInt32 mnWarnCount;
  92
  93     bool noErrors() const { return !mnErrCount /*&& !mnFatalCount*/ && !mnWarnCount; }
  94
  95     ErrorHandler() : mnErrCount(0), /*mnFatalCount(0),*/ mnWarnCount(0)
  96     {}
  97
  98     virtual void SAL_CALL error( const uno::Any& ) override
  99     {
 100         ++mnErrCount;
 101     }
 102
 103     // Just implement FatalError function as it is in XErrorHandler
 104     // This function is never used, as lib2xml doesn't distinguish between error and fatalerror and calls error functions in both cases
 105     virtual void SAL_CALL fatalError( const uno::Any& ) override
 106     {
 107         //++mnFatalCount;
 108     }
 109
 110     virtual void SAL_CALL warning( const uno::Any& ) override
 111     {
 112         ++mnWarnCount;
 113     }
 114 };
 115
 116 struct DocumentHandler
 117     : public ::cppu::WeakImplHelper< xml::sax::XFastDocumentHandler >
 118 {
 119     // XFastContextHandler
 120     virtual void SAL_CALL startFastElement( ::sal_Int32 Element, const uno::Reference< xml::sax::XFastAttributeList >& ) override
 121     {
 122         SAL_INFO(
 123             "unoxml",
 124             "Seen element: " << (Element & 0xFFFF) << " with namespace "
 125                 << (Element & 0xFFFF0000));
 126     }
 127
 128     virtual void SAL_CALL startUnknownElement( const OUString& , const OUString& , const uno::Reference< xml::sax::XFastAttributeList >& ) override
 129     {
 130     }
 131
 132     virtual void SAL_CALL endFastElement( ::sal_Int32 ) override
 133     {
 134     }
 135
 136     virtual void SAL_CALL endUnknownElement( const OUString&, const OUString& ) override
 137     {
 138     }
 139
 140     virtual uno::Reference< xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 , const uno::Reference< xml::sax::XFastAttributeList >& ) override
 141     {
 142         return this;
 143     }
 144
 145     virtual uno::Reference< xml::sax::XFastContextHandler > SAL_CALL createUnknownChildContext( const OUString& , const OUString& , const uno::Reference< xml::sax::XFastAttributeList >& ) override
 146     {
 147         return this;
 148     }
 149
 150     virtual void SAL_CALL characters( const OUString& ) override
 151     {
 152     }
 153
 154     // XFastDocumentHandler
 155     virtual void SAL_CALL startDocument(  ) override
 156     {
 157     }
 158
 159     virtual void SAL_CALL endDocument(  ) override
 160     {
 161     }
 162
 163     virtual void SAL_CALL processingInstruction( const OUString& /*rTarget*/, const OUString& /*rData*/ ) override
 164     {
 165     }
 166
 167     virtual void SAL_CALL setDocumentLocator( const uno::Reference< xml::sax::XLocator >& ) override
 168     {
 169     }
 170 };
 171
 172 struct TokenHandler : public sax_fastparser::FastTokenHandlerBase
 173 {
 174     virtual ::sal_Int32 SAL_CALL getTokenFromUTF8( const uno::Sequence< ::sal_Int8 >& Identifier ) override
 175     {
 176         return Identifier.hasElements() ? Identifier[0] : 0;
 177     }
 178
 179     virtual uno::Sequence< ::sal_Int8 > SAL_CALL getUTF8Identifier( ::sal_Int32 ) override
 180     {
 181         CPPUNIT_ASSERT_MESSAGE( "TokenHandler::getUTF8Identifier() unexpected call",
 182                                 false );
 183         return uno::Sequence<sal_Int8>();
 184     }
 185
 186     virtual sal_Int32 getTokenDirect( const char * /* pToken */, sal_Int32 /* nLength */ ) const override
 187     {
 188         return -1;
 189     }
 190 };
 191
 192 struct BasicTest : public test::BootstrapFixture
 193 {
 194     uno::Reference<XDocumentBuilder>    mxDomBuilder;
 195     rtl::Reference<ErrorHandler>        mxErrHandler;
 196     rtl::Reference<SequenceInputStream> mxValidInStream;
 197     rtl::Reference<SequenceInputStream> mxWarningInStream;
 198     rtl::Reference<SequenceInputStream> mxErrorInStream;
 199
 200     virtual void setUp() override
 201     {
 202         test::BootstrapFixture::setUp();
 203
 204         mxErrHandler.set( new ErrorHandler() );
 205         uno::Reference<XDocumentBuilder> xDB( getMultiServiceFactory()->createInstance("com.sun.star.xml.dom.DocumentBuilder"), uno::UNO_QUERY_THROW );
 206         mxDomBuilder.set( xDB );
 207         mxValidInStream.set( new SequenceInputStream(css::uno::Sequence<sal_Int8>(reinterpret_cast<sal_Int8 const *>(validTestFile), std::size(validTestFile))) );
 208         mxWarningInStream.set( new SequenceInputStream(css::uno::Sequence<sal_Int8>(reinterpret_cast<sal_Int8 const *>(warningTestFile), std::size(warningTestFile))) );
 209         mxErrorInStream.set( new SequenceInputStream(css::uno::Sequence<sal_Int8>(reinterpret_cast<sal_Int8 const *>(errorTestFile), std::size(errorTestFile))) );
 210         mxDomBuilder->setErrorHandler(mxErrHandler);
 211     }
 212
 213     void validInputTest()
 214     {
 215         try
 216         {
 217             CPPUNIT_ASSERT_MESSAGE("Valid input file did not result in XDocument #1",
 218                 mxDomBuilder->parse(mxValidInStream).is());
 219             CPPUNIT_ASSERT_MESSAGE("Valid input file resulted in parse errors",
 220                 mxErrHandler->noErrors());
 221         }
 222         catch (const css::xml::sax::SAXParseException&)
 223         {
 224             CPPUNIT_ASSERT_MESSAGE("Valid input file did not result in XDocument (exception thrown)", false);
 225         }
 226     }
 227
 228     void warningInputTest()
 229     {
 230         try
 231         {
 232             // We DON'T expect exception here, as mxWarningInStream is valid XML Doc
 233             CPPUNIT_ASSERT_MESSAGE("Valid input file did not result in XDocument #2",
 234                 mxDomBuilder->parse(mxWarningInStream).is());
 235         }
 236         catch (const css::xml::sax::SAXParseException& )
 237         {
 238             CPPUNIT_ASSERT_MESSAGE("Valid input file did not result in XDocument #2 (exception thrown)", false);
 239         }
 240         CPPUNIT_ASSERT_MESSAGE("No parse warnings in unclean input file",
 241             mxErrHandler->mnWarnCount);
 242         CPPUNIT_ASSERT_MESSAGE("No parse warnings in unclean input file",
 243             !mxErrHandler->mnErrCount /*&& !mxErrHandler->mnFatalCount*/);
 244     }
 245
 246     void errorInputTest()
 247     {
 248         try
 249         {
 250             // We expect exception here, as mxErrorInStream is invalid XML Doc
 251             CPPUNIT_ASSERT_MESSAGE("Invalid input file result in XDocument #2!",
 252                 !mxDomBuilder->parse(mxErrorInStream).is());
 253             CPPUNIT_ASSERT_MESSAGE("No exception is thrown in unclean input file", false);
 254         }
 255         catch (const css::xml::sax::SAXParseException&)
 256         {
 257             // It's OK to catch an exception here as we parse incorrect XML file
 258         }
 259         CPPUNIT_ASSERT_MESSAGE("No parse errors in unclean input file",
 260             !mxErrHandler->mnWarnCount);
 261         CPPUNIT_ASSERT_MESSAGE("No parse errors in unclean input file",
 262             mxErrHandler->mnErrCount /*&& !mxErrHandler->mnFatalCount*/);
 263     }
 264
 265         // Change the following lines only, if you add, remove or rename
 266     // member functions of the current class,
 267     // because these macros are need by auto register mechanism.
 268     CPPUNIT_TEST_SUITE(BasicTest);
 269     CPPUNIT_TEST(validInputTest);
 270     CPPUNIT_TEST(warningInputTest);
 271     CPPUNIT_TEST(errorInputTest);
 272     CPPUNIT_TEST_SUITE_END();
 273 };
 274
 275 struct SerializerTest : public test::BootstrapFixture
 276 {
 277     uno::Reference<XDocumentBuilder>                         mxDomBuilder;
 278     rtl::Reference<ErrorHandler>                             mxErrHandler;
 279     rtl::Reference<SequenceInputStream>                      mxInStream;
 280     rtl::Reference<DocumentHandler>                          mxHandler;
 281     rtl::Reference<TokenHandler>                             mxTokHandler;
 282     uno::Sequence< beans::Pair< OUString, sal_Int32 > > maRegisteredNamespaces;
 283
 284     void setUp() override
 285     {
 286         test::BootstrapFixture::setUp();
 287
 288         mxErrHandler.set( new ErrorHandler() );
 289         uno::Reference<XDocumentBuilder> xDB( getMultiServiceFactory()->createInstance("com.sun.star.xml.dom.DocumentBuilder"), uno::UNO_QUERY_THROW );
 290         mxDomBuilder.set( xDB );
 291         mxInStream.set( new SequenceInputStream(css::uno::Sequence<sal_Int8>(reinterpret_cast<sal_Int8 const *>(validTestFile), std::size(validTestFile))) );
 292         mxDomBuilder->setErrorHandler(mxErrHandler);
 293         mxHandler.set( new DocumentHandler );
 294         mxTokHandler.set( new TokenHandler );
 295
 296         maRegisteredNamespaces = {
 297             beans::make_Pair(
 298                 OUString( "urn:oasis:names:tc:opendocument:xmlns:office:1.0" ),
 299                 xml::sax::FastToken::NAMESPACE),
 300             beans::make_Pair(
 301                 OUString( "http://www.w3.org/1999/xlink" ),
 302                 2*xml::sax::FastToken::NAMESPACE)
 303         };
 304     }
 305
 306     void serializerTest ()
 307     {
 308         try
 309         {
 310             uno::Reference< xml::dom::XDocument > xDoc =
 311                 mxDomBuilder->parse(mxInStream);
 312             CPPUNIT_ASSERT_MESSAGE("Valid input file did not result in XDocument",
 313                 xDoc.is());
 314             CPPUNIT_ASSERT_MESSAGE("Valid input file resulted in parse errors",
 315                 mxErrHandler->noErrors());
 316
 317             uno::Reference< xml::sax::XSAXSerializable > xSaxSerializer(
 318                 xDoc, uno::UNO_QUERY);
 319             CPPUNIT_ASSERT_MESSAGE("XSAXSerializable not supported",
 320                 xSaxSerializer.is());
 321
 322             uno::Reference< xml::sax::XFastSAXSerializable > xFastSaxSerializer(
 323                 xDoc, uno::UNO_QUERY);
 324             CPPUNIT_ASSERT_MESSAGE("XFastSAXSerializable not supported",
 325                 xSaxSerializer.is());
 326
 327             xFastSaxSerializer->fastSerialize(mxHandler,
 328                 mxTokHandler,
 329                 uno::Sequence< beans::StringPair >(),
 330                 maRegisteredNamespaces);
 331         }
 332         catch (const css::xml::sax::SAXParseException&)
 333         {
 334             CPPUNIT_ASSERT_MESSAGE("Valid input file did not result in XDocument (exception thrown)", false);
 335         }
 336     }
 337
 338     // Change the following lines only, if you add, remove or rename
 339     // member functions of the current class,
 340     // because these macros are need by auto register mechanism.
 341
 342     CPPUNIT_TEST_SUITE(SerializerTest);
 343     CPPUNIT_TEST(serializerTest);
 344     CPPUNIT_TEST_SUITE_END();
 345 };
 346
 347 CPPUNIT_TEST_SUITE_REGISTRATION(BasicTest);
 348 CPPUNIT_TEST_SUITE_REGISTRATION(SerializerTest);
 349 }
 350
 351 // this macro creates an empty function, which will called by the RegisterAllFunctions()
 352 // to let the user the possibility to also register some functions by hand.
 353 CPPUNIT_PLUGIN_IMPLEMENT();
 354
 355 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */