writerperfect/qa/unit/WPXSvStreamTest.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
  10 #include <algorithm>
  11 #include <cassert>
  12 #include <sstream>
  13
  14 #include <memory>
  15
  16 #include <cppunit/extensions/HelperMacros.h>
  17
  18 #include <com/sun/star/io/XInputStream.hpp>
  19 #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
  20 #include <com/sun/star/uno/Reference.hxx>
  21
  22 #include <comphelper/processfactory.hxx>
  23 #include <comphelper/seqstream.hxx>
  24
  25 #include <test/bootstrapfixture.hxx>
  26
  27 #include <WPXSvInputStream.hxx>
  28
  29 namespace io = css::io;
  30 namespace ucb = css::ucb;
  31 namespace uno = css::uno;
  32
  33 using std::shared_ptr;
  34 using std::unique_ptr;
  35
  36 using librevenge::RVNGInputStream;
  37 using librevenge::RVNG_SEEK_CUR;
  38 using librevenge::RVNG_SEEK_END;
  39 using librevenge::RVNG_SEEK_SET;
  40
  41 using std::equal;
  42
  43 using writerperfect::WPXSvInputStream;
  44
  45 namespace
  46 {
  47 class WPXSvStreamTest : public test::BootstrapFixture
  48 {
  49 public:
  50     CPPUNIT_TEST_SUITE(WPXSvStreamTest);
  51     CPPUNIT_TEST(testRead);
  52     CPPUNIT_TEST(testSeekSet);
  53     CPPUNIT_TEST(testSeekCur);
  54     CPPUNIT_TEST(testSeekEnd);
  55     CPPUNIT_TEST(testStructured);
  56     CPPUNIT_TEST_SUITE_END();
  57
  58 private:
  59     void testRead();
  60     void testSeekSet();
  61     void testSeekCur();
  62     void testSeekEnd();
  63     void testStructured();
  64 };
  65
  66 const char aText[] = "hello world";
  67 constexpr OUStringLiteral aOLEFile = u"/writerperfect/qa/unit/data/stream/fdo40686-1.doc";
  68 constexpr OUStringLiteral aZipFile = u"/writerperfect/qa/unit/data/stream/test.odt";
  69
  70 shared_ptr<RVNGInputStream> lcl_createStream()
  71 {
  72     using comphelper::SequenceInputStream;
  73
  74     const css::uno::Sequence<sal_Int8> aData(reinterpret_cast<const sal_Int8*>(aText),
  75                                              sizeof aText);
  76     const uno::Reference<io::XInputStream> xInputStream(new SequenceInputStream(aData));
  77
  78     shared_ptr<RVNGInputStream> pInputStream;
  79     if (xInputStream.is())
  80         pInputStream = std::make_shared<WPXSvInputStream>(xInputStream);
  81
  82     return pInputStream;
  83 }
  84
  85 shared_ptr<RVNGInputStream> lcl_createStreamForURL(const OUString& rURL)
  86 {
  87     using uno::Reference;
  88     using uno::UNO_QUERY_THROW;
  89
  90     const Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext(),
  91                                                      css::uno::UNO_SET_THROW);
  92     const Reference<ucb::XSimpleFileAccess> xFileAccess(
  93         xContext->getServiceManager()->createInstanceWithContext(
  94             u"com.sun.star.ucb.SimpleFileAccess"_ustr, xContext),
  95         UNO_QUERY_THROW);
  96     const Reference<io::XInputStream> xInputStream(xFileAccess->openFileRead(rURL),
  97                                                    css::uno::UNO_SET_THROW);
  98
  99     return std::make_shared<WPXSvInputStream>(xInputStream);
 100 }
 101
 102 void lcl_testSubStreams(const shared_ptr<RVNGInputStream>& pInput)
 103 {
 104     shared_ptr<RVNGInputStream> pSubStream;
 105
 106     // all valid substreams can be read
 107     for (std::size_t i = 0; i != pInput->subStreamCount(); ++i)
 108     {
 109         std::ostringstream msg("opening substream ");
 110         msg << i;
 111         pSubStream.reset(pInput->getSubStreamById(i));
 112         CPPUNIT_ASSERT_MESSAGE(msg.str(), bool(pSubStream));
 113     }
 114
 115     // invalid substreams cannot be read
 116     pSubStream.reset(pInput->getSubStreamById(pInput->subStreamCount()));
 117     CPPUNIT_ASSERT(!pSubStream);
 118 }
 119
 120 void WPXSvStreamTest::testRead()
 121 {
 122     const shared_ptr<RVNGInputStream> pInput(lcl_createStream());
 123     const unsigned long nLen = sizeof aText;
 124
 125     unsigned long nReadBytes = 0;
 126     const unsigned char* pData = nullptr;
 127     const unsigned char* const pTextOrig = reinterpret_cast<const unsigned char*>(aText);
 128     const unsigned char* pText = pTextOrig;
 129
 130     // reading by small pieces
 131     pData = pInput->read(1UL, nReadBytes);
 132     CPPUNIT_ASSERT_EQUAL(1UL, nReadBytes);
 133     CPPUNIT_ASSERT(equal(pText, pText + nReadBytes, pData));
 134     CPPUNIT_ASSERT(!pInput->isEnd());
 135     pText += nReadBytes;
 136
 137     pData = pInput->read(2UL, nReadBytes);
 138     CPPUNIT_ASSERT_EQUAL(2UL, nReadBytes);
 139     CPPUNIT_ASSERT(equal(pText, pText + nReadBytes, pData));
 140     CPPUNIT_ASSERT(!pInput->isEnd());
 141     pText += nReadBytes;
 142
 143     pData = pInput->read(3UL, nReadBytes);
 144     CPPUNIT_ASSERT_EQUAL(3UL, nReadBytes);
 145     CPPUNIT_ASSERT(equal(pText, pText + nReadBytes, pData));
 146     CPPUNIT_ASSERT(!pInput->isEnd());
 147     pText += nReadBytes;
 148
 149     assert(nLen > 6);
 150     pData = pInput->read(nLen - 6, nReadBytes);
 151     CPPUNIT_ASSERT_EQUAL(nLen - 6, nReadBytes);
 152     CPPUNIT_ASSERT(equal(pText, pText + nReadBytes, pData));
 153     CPPUNIT_ASSERT(pInput->isEnd());
 154
 155     // reading everything at once
 156     pInput->seek(0, RVNG_SEEK_SET);
 157     pText = pTextOrig;
 158
 159     pData = pInput->read(nLen, nReadBytes);
 160     CPPUNIT_ASSERT_EQUAL(nLen, nReadBytes);
 161     CPPUNIT_ASSERT(equal(pText, pText + nReadBytes, pData));
 162     CPPUNIT_ASSERT(pInput->isEnd());
 163
 164     // trying to read too much
 165     pInput->seek(0, RVNG_SEEK_SET);
 166     pText = pTextOrig;
 167
 168     pData = pInput->read(nLen + 1, nReadBytes);
 169     CPPUNIT_ASSERT_EQUAL(nLen, nReadBytes);
 170     CPPUNIT_ASSERT(equal(pText, pText + nReadBytes, pData));
 171     CPPUNIT_ASSERT(pInput->isEnd());
 172
 173     // trying to read nothing
 174     pInput->seek(0, RVNG_SEEK_SET);
 175     pData = pInput->read(0UL, nReadBytes);
 176     CPPUNIT_ASSERT_EQUAL(0UL, nReadBytes);
 177     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 178     CPPUNIT_ASSERT_EQUAL(static_cast<const unsigned char*>(nullptr), pData);
 179     CPPUNIT_ASSERT(!pInput->isEnd());
 180 }
 181
 182 void WPXSvStreamTest::testSeekSet()
 183 {
 184     const shared_ptr<RVNGInputStream> pInput(lcl_createStream());
 185     const long nLen = sizeof aText;
 186
 187     // check initial state
 188     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 189     CPPUNIT_ASSERT(!pInput->isEnd());
 190
 191     // valid seeks
 192     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(0, RVNG_SEEK_SET));
 193     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 194     CPPUNIT_ASSERT(!pInput->isEnd());
 195
 196     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(1, RVNG_SEEK_SET));
 197     CPPUNIT_ASSERT_EQUAL(1L, pInput->tell());
 198     CPPUNIT_ASSERT(!pInput->isEnd());
 199
 200     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(nLen, RVNG_SEEK_SET));
 201     CPPUNIT_ASSERT_EQUAL(nLen, pInput->tell());
 202     CPPUNIT_ASSERT(pInput->isEnd());
 203
 204     // go back to the beginning
 205     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(0, RVNG_SEEK_SET));
 206     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 207
 208     // invalid seeks
 209     CPPUNIT_ASSERT(0 != pInput->seek(-1, RVNG_SEEK_SET));
 210     // Okay, this is not defined. But it is what the WPXSvInputStream
 211     // does ATM and it is reasonable.
 212     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 213     CPPUNIT_ASSERT(!pInput->isEnd());
 214
 215     CPPUNIT_ASSERT(0 != pInput->seek(nLen + 1, RVNG_SEEK_SET));
 216     CPPUNIT_ASSERT_EQUAL(nLen, pInput->tell());
 217     CPPUNIT_ASSERT(pInput->isEnd());
 218 }
 219
 220 void WPXSvStreamTest::testSeekCur()
 221 {
 222     const shared_ptr<RVNGInputStream> pInput(lcl_createStream());
 223     const long nLen = sizeof aText;
 224
 225     // check initial state
 226     CPPUNIT_ASSERT(!pInput->isEnd());
 227     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 228
 229     // valid seeks
 230
 231     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(0, RVNG_SEEK_CUR));
 232     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 233     CPPUNIT_ASSERT(!pInput->isEnd());
 234
 235     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(1, RVNG_SEEK_CUR));
 236     CPPUNIT_ASSERT_EQUAL(1L, pInput->tell());
 237     CPPUNIT_ASSERT(!pInput->isEnd());
 238
 239     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(-1, RVNG_SEEK_CUR));
 240     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 241     CPPUNIT_ASSERT(!pInput->isEnd());
 242
 243     // go back to the beginning
 244     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(0, RVNG_SEEK_SET));
 245     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 246
 247     // invalid seeks
 248     CPPUNIT_ASSERT(0 != pInput->seek(-1, RVNG_SEEK_CUR));
 249     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 250     CPPUNIT_ASSERT(!pInput->isEnd());
 251
 252     CPPUNIT_ASSERT(0 != pInput->seek(nLen + 1, RVNG_SEEK_CUR));
 253     CPPUNIT_ASSERT_EQUAL(nLen, pInput->tell());
 254     CPPUNIT_ASSERT(pInput->isEnd());
 255 }
 256
 257 void WPXSvStreamTest::testSeekEnd()
 258 {
 259     const shared_ptr<RVNGInputStream> pInput(lcl_createStream());
 260     const long nLen = sizeof aText;
 261
 262     // check initial state
 263     CPPUNIT_ASSERT(!pInput->isEnd());
 264     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 265
 266     // valid seeks
 267     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(0, RVNG_SEEK_END));
 268     CPPUNIT_ASSERT_EQUAL(nLen, pInput->tell());
 269     CPPUNIT_ASSERT(pInput->isEnd());
 270
 271     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(-1, RVNG_SEEK_END));
 272     CPPUNIT_ASSERT_EQUAL(nLen - 1, pInput->tell());
 273     CPPUNIT_ASSERT(!pInput->isEnd());
 274
 275     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(-nLen, RVNG_SEEK_END));
 276     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 277     CPPUNIT_ASSERT(!pInput->isEnd());
 278
 279     // go back to the beginning
 280     CPPUNIT_ASSERT_EQUAL(0, pInput->seek(0, RVNG_SEEK_SET));
 281     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 282
 283     // invalid seeks
 284     CPPUNIT_ASSERT(0 != pInput->seek(1, RVNG_SEEK_END));
 285     CPPUNIT_ASSERT_EQUAL(nLen, pInput->tell());
 286     CPPUNIT_ASSERT(pInput->isEnd());
 287
 288     CPPUNIT_ASSERT(0 != pInput->seek(-nLen - 1, RVNG_SEEK_END));
 289     CPPUNIT_ASSERT_EQUAL(0L, pInput->tell());
 290     CPPUNIT_ASSERT(!pInput->isEnd());
 291 }
 292
 293 void WPXSvStreamTest::testStructured()
 294 {
 295     // OLE2
 296     {
 297         const shared_ptr<RVNGInputStream> pInput(
 298             lcl_createStreamForURL(m_directories.getURLFromSrc(aOLEFile)));
 299         assert(bool(pInput));
 300
 301         CPPUNIT_ASSERT(pInput->isStructured());
 302         CPPUNIT_ASSERT_EQUAL(static_cast<unsigned>(2), pInput->subStreamCount());
 303         lcl_testSubStreams(pInput);
 304
 305         // check for existing substream
 306         CPPUNIT_ASSERT(pInput->existsSubStream("WordDocument"));
 307         unique_ptr<RVNGInputStream> pSubStream(pInput->getSubStreamByName("WordDocument"));
 308         CPPUNIT_ASSERT(bool(pSubStream));
 309         CPPUNIT_ASSERT(!pSubStream->isEnd());
 310
 311         // check for not existing substream
 312         CPPUNIT_ASSERT(!pInput->existsSubStream("foo"));
 313         pSubStream.reset(pInput->getSubStreamByName("foo"));
 314         CPPUNIT_ASSERT(!pSubStream);
 315     }
 316
 317     // Zip
 318     {
 319         const shared_ptr<RVNGInputStream> pInput(
 320             lcl_createStreamForURL(m_directories.getURLFromSrc(aZipFile)));
 321         assert(bool(pInput));
 322
 323         CPPUNIT_ASSERT(pInput->isStructured());
 324         CPPUNIT_ASSERT_EQUAL(static_cast<unsigned>(9), pInput->subStreamCount());
 325         lcl_testSubStreams(pInput);
 326
 327         // check for existing substream
 328         CPPUNIT_ASSERT(pInput->existsSubStream("content.xml"));
 329         unique_ptr<RVNGInputStream> pSubStream(pInput->getSubStreamByName("content.xml"));
 330         CPPUNIT_ASSERT(bool(pSubStream));
 331         CPPUNIT_ASSERT(!pSubStream->isEnd());
 332
 333         // check for not existing substream
 334         CPPUNIT_ASSERT(!pInput->existsSubStream("foo"));
 335         pSubStream.reset(pInput->getSubStreamByName("foo"));
 336         CPPUNIT_ASSERT(!pSubStream);
 337     }
 338
 339     // not structured
 340     {
 341         const shared_ptr<RVNGInputStream> pInput(lcl_createStream());
 342
 343         CPPUNIT_ASSERT(!pInput->isStructured());
 344         CPPUNIT_ASSERT_EQUAL(static_cast<unsigned>(0), pInput->subStreamCount());
 345         CPPUNIT_ASSERT(!pInput->existsSubStream("foo"));
 346         CPPUNIT_ASSERT(!pInput->getSubStreamByName("foo"));
 347         CPPUNIT_ASSERT(!pInput->getSubStreamById(42));
 348         CPPUNIT_ASSERT(!pInput->subStreamName(42));
 349     }
 350 }
 351
 352 CPPUNIT_TEST_SUITE_REGISTRATION(WPXSvStreamTest);
 353 }
 354
 355 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */